Intel Galileo Geliştirme Kartı üzerinde Gömülü Sistem Tasarımı

Transkript

1 Intel Galileo Geliştirme Kartı üzerinde Gömülü Sistem Tasarımı Emre Göncü, Çağrı Bağbaba, Buse Ustaoğlu, Berna Örs Yalçın 10 Mart 2015

2 2

3 Şekil Listesi 2.1 Aygıt Yöneticisi Gadget Serial v Güncelleme Güncel Intel Galileo geliştirme kartı Karta Kodun Yüklenmesi Network Enable Kapatılması Terminaller Program Çıktısı Potansiyometre Devresi Easy Pulse Sensor Easy Pulse Sensor Çıkış Grafiği image1.jpeg result.jpeg capture.png edges.png Piezo elemanlarının dirençler ile bağlantısı Hairless yazılımı Xylophone-PC ekran görünümü GarageBand programı ekran görünümü

4 4 ŞEKIL LISTESI

5 Tablo Listesi 3.1 ADC ye Ait Pinler

6 6 TABLO LISTESI

7 İçindekiler 1 Giriş Dersin Amaçları Dersin Kaynakları Lab # 1: Laboratuvar Öncesi Giriş Deneyin Süresi Deneyin Amaçları Deneyin Kazanımları Gerekli Ön Bilgiler Materyaller ve Kaynaklar Deneyin İşlenişi Led Blink Uygulaması Gömülü LINUX Lab #2: Analog Dijital Dönüştürücü (ADC) Kullanılarak Veri Alma Giriş Deney Süresi Deneyin Amaçları Deneyin Kazanımları Gerekli Ön Bilgiler Materyaller ve Kaynaklar Deneyin İşlenişi Lab #3: Easy Pulse Sensörü ile Nabız Ölçümü Giriş Deney Süresi Deneyin Amaçları Deneyin Kazanımları Gerekli Ön Bilgiler Materyaller ve Kaynaklar Deneyin İşlenişi Node.js ile web sunucusu oluşturulması Javascript kodunda Linux Bash Script kodunu çağırma Dakikalık ölçülen nabız değerlerinin web sunucusu ile dışarı verilmesi Lab #4: OpenCV Kütüphanesini Kullanarak Resim İşleme Uygulamaları Giriş Deney Süresi Deneyin Amaçları Deneyin Kazanımları Gerekli Ön Bilgiler Materyaller ve Kaynaklar Deneyin İşlenişi OpenCV kütüphanesi Webcam in Intel Galileo geliştirme kartına bağlanması

8 8 İÇINDEKILER Bir Kenar Dedektörü Algoritmasının Gerçeklenmesi Lab #5: Pololu Servo Sürücüsü ile Servo Motor Kontrolü Giriş Deney Süresi Deney Amaçları Deney Kazanımları Gerekli Ön Bilgiler Materyaller ve Kaynaklar Deneyin İşlenişi USB ile libusb haberleşmesi Pololu Servo sürücüsünün USB ile kontrolü Lab #6: Xylaphone Giriş Deney Süresi Deneyin Amaçları Deneyin Kazanımları Gerekli Ön Bilgiler Materyaller ve Kaynaklar Deneyin İşlenişi

9 Bölüm 1 Giriş Bu derste Intel Galileo geliştirme kartları üzerinde gömülü sistem tasarımı öğretilecektir. Bu amaçla altı adet deney yapılacaktır. 1.1 Dersin Amaçları 1. Intel Galileo geliştirme kartlarının tanıtımı 2. Kartlarınn Gömülü Linux işletim sistemi ile birlikte kullanılması 3. Kartlara dış dünyadan ölçüm alacak sensörler bağlayarak veri toplanması 4. Toplanan verileri kullanacak uygulamalar geliştirilmesi 1.2 Dersin Kaynakları 1. Matt Richardson, Getting Started with Intel Galileo Paperback, Maker Media, Inc; 1 edition (April 10, 2014). 2. Manoel Carlos Ramon, Intel Galileo and Intel Galileo Gen 2: API Features and Arduino Projects for Linux Programmers, Apress; 1 edition (December 27, 2014) 3. Agus Kurniawan, Getting Started with Intel IoT and Intel Galileo, PE Press; 1 edition (October 17, 2014) 4. Manoel Ramon, Intel Galileo Gen 2 and Intel Edison for Beginners: A Hands-on Introduction, Apress; 2015 edition (January 30, 2015) 9

10 10 BÖLÜM 1. GIRIŞ

11 Bölüm 2 Lab # 1: Laboratuvar Öncesi 2.1 Giriş Bu deneyde Intel Galileo geliştirme kartının, Ardunio IDE nin ve gömülü Linux un tanıtılması yapılacaktır. Bu amaçla Led Blink ve hello world uygulamaları gerçeklenecektir Deneyin Süresi 2 Hafta Deneyin Amaçları Intel Galileo geliştirme kartının tanıtılması, Ardunio IDE nin tanıtılması, Led Blink örneğinin kart üzerinde çalıştırılması ve analiz edilmesi, Kart üzerinde mevcut olan gömülü Linux ile hello world uygulamasının gerçeklenmesi Deneyin Kazanımları Bu deneyden sonra bir yazılımın nasıl geliştirildiği ve kart üzerine nasıl yüklendiği öğrenilecektir. Aynı zamanda Intel Galileo tarafından oluşturulan bir programın tüm süreci kavranmış olacaktır Gerekli Ön Bilgiler C programlama dili bilinmesi gerekmektedir Materyaller ve Kaynaklar Intel Galileo geliştirme kartı Üzerinde Gömülü Linux yüklü olan SD kart Ardunio IDE ve kaynak kodların indirilmesi için Kartın bağlı olduğu PC de Ubuntu işletim sistemi yüklenmiş olmalı. ( com/12.04/) Yocto Projesi için 11

12 12 BÖLÜM 2. LAB # 1: LABORATUVAR ÖNCESI 2.2 Deneyin İşlenişi Led Blink Uygulaması Öncelikle kart 5V luk harici beslemesinden güç kaynağına bağlanarak beslemesi sağlanır. Daha sonra kart, üzerinde yer alan USB CLIENT portundan bilgisayara bağlanır. Bu bağlantı için USB A to Micro B cable to USB kablosu kullanılmalıdır. Bağlantının sorunsuz olduğunu anlamak için kart üzerinde yer alan USB ye ait led ve güç kaynağına ait ledlerin yanması beklenmektedir. Bu aşamada Intel Galileo geliştirme kartına ait Ardunio IDE si bilgisayara indirilmelidir. Bunun için ilgili link kullanılacaktır. Buradan indirilen dosya C klasörüne kaydedilmelidir. Kart ilk kez bilgisayara bağlandığında, bilgisayarın ilgili sürücüleri otomatik olarak yüklemesi mümkün olmamaktadır. Bu sebeple denetim masası altında sistem ve güvenlik başlığına gidilerek, aygıt sürücüsüne ulaşılmalıdır. Burada Şekil 2.1 de görüldüğü gibi Diğer Aygıtlar altında Gadget Serial v2.4 görülmektedir. Bu kartın sürücüsüdür. Şekil 2.2 deki gibi Gadget Serial v2.4 e sağ tıklanarak Sürücü Yazılımını Güncelleştir denmelidir. Açılan pencereden sürücünün bilgisayardaki bir klasörden seçileceği belirtilerek güncelleme işlemi gerçekleştirilir (Şekil 2.3). Güncelleme işlemi tamamlandıktan sonra, Şekil 2.4 te görüldüğü gibi karta ait sürücü tanınmış olmalıdır. Şekil 2.1: Aygıt Yöneticisi Bu aşamada daha önce indirilen Ardunio klasörüne girilerek ardunio.exe çalıştırılmalıdır. Burada üstteki araçlar sekmesinden karta gelinerek seçili olan kartın Intel Galileo olmasına dikkat edilmelidir. Araçlar sekmesinden ilgili seri port tıklanarak seçili hale getirilmelidir. Yardım sekmesinde Intel Galileo Firmware Update yapılarak gerekli güncellemeler yapılmalıdır. Güncelleme sırasında kartın gücü kesilmemelidir. Yukarıdaki aşamalar hatasız bir şekilde tamamlandıktan sonra Led Blink uygulaması yapılabilir duruma gelinmiştir. Bunun için Dosya sekmesinden Örnekler içinden 01. Basics başlığından Blink seçilmelidir. Daha sonra Şekil 2.5 teki gösterilen yere tıklanarak karta kodu yükleme işi yapılır. Karta bakıldığında GP Led inin yanıp söndüğü görülecektir.

13 2.2. DENEYIN İŞLENIŞI 13 Şekil 2.2: Gadget Serial v2.4 Şekil 2.3: Güncelleme Gömülü LINUX Deney sırasında öğrencilere verilen kart üzerindeki SD bellekte Yocto projesi ile oluşturulmuş Gömülü LI- NUX işletim sistemi bulunmaktadır. Yocto, gömülü sistemler üzerinde koşacak LINUX işletim sistemi oluşturmak için kullanılan açık kaynak kodlu bir projedir. Daha fazla bilgi için org/ sitesi ziyaret edilebilir.

14 14 BÖLÜM 2. LAB # 1: LABORATUVAR ÖNCESI Şekil 2.4: Güncel Intel Galileo geliştirme kartı Şekil 2.5: Karta Kodun Yüklenmesi Öncelikle PC tarafında bazı konfigürasyonlar yapılması gerekmektedir. Bunun için Şekil 2.6 da verildiği gibi

15 2.2. DENEYIN I S LENIS I 15 Networking Enable kapatılmalıdır. S ekil 2.6: Network Enable Kapatılması As ag ıdaki komut ac ılan terminal ekranına girilmelidir. # sudo ifconfig eth PC yi karta bag lamak ic in SSH protokolu u zerinden as ag ıdaki komut terminal ekranına girilmelidir. Kart u zerinde go mu lu LINUX is letim sisteminde gerekli ayarlar yapılarak (connmanctl ile) kartın statik olarak adresini alması sag lanmıs tır. # ssh root@ Komut girildikten sonra s ifre istenir. SD kart u zerinde yu klenmis olan go mu lu Linux da root s ifresi 1234 olarak daha o nceden belirlenmis tir. ssh komutu girildikten sonra istenen s ifre yerine bu s ifre yazılır. S ifre is lemi bittikten sonra Intel Galileo gelis tirme kartına bag lanılmıs olunur. Linux u zerinde ilk uygulamanın c alıs tırılması ic in PC de yeni bir terminal ac ılır. Bo ylece S ekil 2.7 deki gibi birisi Intel Galileo ic in dig eri PC ic in olmak u zere ekranda iki terminal ac ık olmalıdır. S ekil 2.7: Terminaller

16 16 BÖLÜM 2. LAB # 1: LABORATUVAR ÖNCESI PC üzerinde aşağıdaki komut girilir. #nano /home/username/hellogalileo.c Daha sonra aşağıda görülen kod yazılmalıdır. #include <stdio.h> int main() printf("hello Galileo\n"); return 0; Ctrl+X ve Enter komutları ile dosya kaydedilir. Aşağıdaki kod girilerek yazılan C kodu PC üzerinde Ubuntu ile birlikte gelen GNU GCC derleyicisi ile 32-bit x86 işlemcisi için -m32 parametresi kullanılarak derlenir. Böylece cross compiler kullanılmaya gerek kalmamıştır. # gcc -m32 /home/username/hellogalileo.c -o /home/username/hellogalileo Aşağıdaki komut girilerek yazılan program (hellogalileo) Intel Galileo geliştirme kartına yollanır. #scp /home/username/hellogalileo root@ :/home Intel Galileo geliştirme kartı için açılan pencereye geçilir ve aşağıdaki komut yazılır. #cd /home Şekil 2.8 deki gibi program çıktısı terminal ekranı üzerinde görülecektir. Şekil 2.8: Program Çıktısı

17 Bölüm 3 Lab #2: Analog Dijital Dönüştürücü (ADC) Kullanılarak Veri Alma 3.1 Giriş Bu deneyde potansiyometre ile direnç değeri değiştirilerek çıkış geriliminin değişen değerleri ekrana bastırılacaktır Deney Süresi 1 hafta Deneyin Amaçları 1. ADC kullanımının öğrenilmesi, 2. Kart üzerinde Linux kullanımının geliştirilmesi, 3. Linux içerisinde uygulama ve script yazmak Deneyin Kazanımları Kart üzerindeki işletim sisteminde uygulama çalıştırılması ve kartın ADC sinin kullanımı detaylı bir şekilde öğrenilecektir Gerekli Ön Bilgiler C++ ve script shell yazımı hakkında bilgi gereklidir Materyaller ve Kaynaklar Intel Galileo geliştirme kartı Cadet ve kablolar 3.2 Deneyin İşlenişi İlk adım olarak üzerinde Linux çalışan karta bağlanılmalıdır. Bu amaçla aşağıdaki komutlar terminal ekranına girilmelidir. # sudo ifconfig eth PC yi karta bağlamak için şu komut girilmelidir. # ssh root@

18 18 BÖLÜM 3. LAB #2: ANALOG DIJITAL DÖNÜŞTÜRÜCÜ (ADC) KULLANILARAK VERI ALMA Daha sonra Şekil 3.1 de görülen devre Cadet üzerinde kurulmalıdır. Devrenin beslemesi 5V, toprağı ise Cadet üzerindeki 0V luk beslemelerden alınacaktır. Vout çıkışı Intel Galileo geliştime kartın ADC sine bağlanacaktır. Bağlanacağı pin A0 olmalıdır. Devredeki değişken direnç için Cadet üzerindeki potansiyometre kullanılacaktır. Diğer direnç sabit olabilir. Şekil 3.1: Potansiyometre Devresi Kartın A0 pininin girişine gelen dataları alabilmesi için A0 pinine ait bazı ayarlamalar yapılması gerekmektedir. Intel Galileo geliştirme kartı üzerinde Analog Devices AD7298 ADC IC bulunmaktadır. Bu ADC 8 kanallıdır fakat yalnızca 6 tanesi Intel Galileo geliştirme kartına bağlıdır. Her bir kanalın çözünürlüğü 12 bittir. Dolayısıyla sonuç değerleri aralığında olacaktır. 0 değeri giriş gerilimi ya da toprak, 4095 ise 5V luk besleme kaynağı olarak yorumlanabilir. Analog girişlere izin vermek için aşağıdaki komutlar karta üzerinde açık olan terminal ekranına girilmelidir. root@clanton: # echo -n 0 /sys/class/gpio/export root@clanton: # echo -n out /sys/class/gpio/gpio0/direction root@clanton: # echo -n 0 /sys/class/gpio/gpio0/value İlk echo komutu A0 multiplexer i için kullanılan 0. GPIO portunu dışarıya alır. İkinci echo komutu çıkışlar için GPIO portunu konfigüre eder. Üçüncü echo komutu ise A0 ı ADC çipine bağlar. ADC ye ait pinlerle ilgili bilgiler Tablo 3.1 deki gibidir. Mux Selector Cypress GPIO Pin Linux Dir Initial Setup 0 1 GPIO ID AD7298:VIN0 IO14 GPORT3 BIT1 PWM5 37 O 0 AD7298:VIN1 IO15 GPORT3 BIT0 PWM7 36 O 0 AD7298:VIN2 IO16 GPORT0 BIT7 PWM1 23 O 0 AD7298:VIN3 IO17 GPORT0 BIT6 PWM3 22 O 0 AD7298:VIN4 IO18 GPORT0 BIT5 PWM5 21 O 0 AD7298:VIN5 IO19 GPORT0 BIT4 PWM7 20 O 0 Tablo 3.1: ADC ye Ait Pinler Buraya kadar yapılan işlemler sayesinde kart A0 girişine gelen dataları alabilecek duruma gelmiştir. Şimdi ise bu dataları ekrana bastırılması ve gerekli işlemlerin yapılabilmesi gerekmektedir. Bu amaçla bir C kodu ve script yazılmalıdır. Terminal ekranında vi metin editörü ile şu kod yazılmalıdır ve script.sh şeklinde kaydedilmelidir. (cat /sys/bus/iio/devices/iiodevice0/in voltage0 raw)>kk.txt

19 3.2. DENEYIN İŞLENIŞI 19 Bu script sayesinde A0 a gelen datalar terminal ekranına alınır ve kk.txt ismi verilen dosyaya kaydedilir. Potansiyometre ile direnç değeri her değiştirildiğinde Vout geriliminin değişeceği de aşikardır. Burada amaç değişen gerilim değerlerini de ekranda görebilmektir. Bunu sağlamak için bir C++ kodu yazılmalıdır. Kart üzerindeki Linux işletim sistemindeki terminalde vi editörüyle şu C++ kodu yazılmalıdır. #include <iostream > #include <stdlib.h> #include <stdio.h> using namespace std; int main() FILE *in; char buff[5]; while(1) system("./script.sh"); if(!(in=popen("cat kk.txt","r"))) return 1; while(fgets(buff,sizeof(buff),in)!=null) cout << buff <<endl; pclose(in); return 0; Bu C++ kodu aracılığıyla gelen her veri ekrana bastırılacaktır. Potansiyometreden direnç değeri değiştirildiği anda değerlerin değişiminin ekranda gözükmesi gerekmektedir. Görüldüğü gibi C++ kodu içerisinde daha önce yazılan script kodunun çağrılması gerekmektedir. C++ kodu terminal ekrana aşağıdaki kod yazılarak derlenmelidir. $CXX adc.cpp pkg-config opencv cflags libs -o adc Derlenen C++ kodu terminale./adc yazılarak çalıştırılır ve ilgili değerler ekranda görülür.

20 20 BÖLÜM 3. LAB #2: ANALOG DIJITAL DÖNÜŞTÜRÜCÜ (ADC) KULLANILARAK VERI ALMA

21 Bölüm 4 Lab #3: Easy Pulse Sensörü ile Nabız Ölçümü 4.1 Giriş Bu deneyde daha önceki deneylerde edinilmiş olunan analog sayısal dönüştürücü kullanım tecrübeleri Node.js kullanılarak oluşturulacak olan web sunucusu uygulaması ile birleştirilecektir. Easy Pulse sensörü ile ölçülen nabız değerleri (nabız sayısı/dakika) oluşturulan web sunucusana yüklenecektir. Web sunucusuna aynı ağdan kendi tarayıcısı ile erişen bir kişi sayfayı her yenilediğinde yeni ölçüm değerini alacaktır Deney Süresi 1 Hafta Deneyin Amaçları 1. Node.js kullanılarak web sunucusu oluşturma bilgisinin öğrencilere aktarılması 2. ADC kullanılarak analog girişlerden okuma ve okunan bilginin yorumlanılması Deneyin Kazanımları Bu deneyden sonra Node.js kullanılarak web sunucusu oluşturabilme ve ADC kullanılarak analog girişlerden veri okuma ve okunan verinin yorumlanabilmesi becerileri kazanılacaktır. EPS sayısal çıkış da verebilmesine rağmen bu deneyde öğrencilerin ADC kullanımında daha çok tecrübe kazanmaları için analog çıkışı kullanılacaktır Gerekli Ön Bilgiler Easy Pulse Sensor (EPS) nabız ölçmek için kullanılan bir sensördür (Şekil 4.1). Bu sensör ile parmak ucundan nabız ölçümü yapılabilmektedir. EPS parmağın bir ucundan kızıl ötesi ışık verir, parmağın diğer tarafında da fotodedektör ile bu gelen kızıl ötesi ışığın yoğunluğu ile orantılı bir çıkış verilir. Bu ışığın yoğunluğu parmaktaki damarlardan geçen kanın seviyesi ile orantılıdır. Bu sayede Şekil 4.2 deki gibi bir çıkış alınır. EPS ile ilgili daha geniş bilgi için aşağıdaki link ile yönlendirilen site incelenebilir (Şekil 4.1 ve Şekil 4.2 de verilen resimler de bu siteden alınmıştır): Materyaller ve Kaynaklar Intel Galileo geliştirme kartı Easy Pulse Sensor v1.1 21

22 22 BÖLÜM 4. LAB #3: EASY PULSE SENSÖRÜ ILE NABIZ ÖLÇÜMÜ Şekil 4.1: Easy Pulse Sensor Şekil 4.2: Easy Pulse Sensor Çıkış Grafiği Java script kodu Easy Pulse Sensoru için döküman Deneyin İşlenişi

23 4.2. DENEYIN İŞLENIŞI 23 EPS nin Intel Galileo geliştirme kartına bağlanması EPS nin VCC ve GND girişleri Intel Galileo geliştirme kartının VCC ve GND çıkışlarına, EPS nin AO (Analog output) çıkışı Intel Galileo kartının A0 ADC girişine bağlanır. İlk deneyde anlatılan şekilde SSH protokolü ile Intel Galileo kartına bağlanılır. Daha sonra ADC deneyinin başında anlatılan Linux komutları kullanılarak EPS den gelen değerler okunur Node.js ile web sunucusu oluşturulması İlk deneyde anlatıldığı gibi SSH protokolü ile Galileo kartına bağlanılır. Daha sonra aşağıdaki komut ile home dizini içinde nodejs diye yeni bir dizin oluşturulur. # mkdir /home/nodejs Bu dizin içerisinde vi editörü ile aşağıda verilen java script kodunu içeren hello.js diye bir dosya oluşturulur. (Bu kod sitesinden alınmıştır.) var http = require( http ); http. createserver( function (req, res) res. writehead(200, Content -Type : text/plain ); res.end( Hello World\n ); ).listen(1337, X.X.X.X ); console.log( Server running at ); Burada X.X.X.X yerine Lab 1 den itibaren belirlenen Intel Galileo geliştirme kartının IP adresi ( ) girilir. Aynı ağ içerisinde bulunan bir PC ile tarayıcıya yazıldığında sayfada Hello World yazdığı görülür Javascript kodunda Linux Bash Script kodunu çağırma Bu deneyde oluşturulan web sunucusunun bazı Linux komutlarını çağırması gerekmektedir. Çünkü ADC den okunan veri web sunucusu ile dışarıya verilecektir. Bunun için de daha önceden oluşturulan bir linux script kodunun java script kodunda nasıl çağrılacağı gösterilecektir. Aşağıdaki komut ile nodejs içerisinde vi editörü ile script.sh bir dosya oluşturulur. # vi /nodejs/script.sh vi editöründe aşağıdaki Linux komutu yazılır ve dosyaya kaydedilir. echo Ben bir Linux scriptiyim Daha sonra vi editörü ile aşağıdaki java script kodu linuxscript.js isimli dosya şeklinde kaydedilir. var http = require("http"), exec = require(" child_process").exec; function onrequest(request, response) console.log("request received."); response. writehead(200, "Content -Type": "text/plain"); // "response"ta bulunan değer başlık olarak web sayfasına yazılır. // aşağıdaki komut sayesinde daha önceden yazılmış olan script.sh scripti çalıştırılır exec( sh script.sh, function (err, stdout, stderr) if (err) handleerror(); Print stdout/stderr to console console.log(stdout); console.log(stderr); // hatasız bir şekilde komut çalışmışsa bu komutun çıktısı " response"a yazılır. response.write(stdout); response.end();

24 24 BÖLÜM 4. LAB #3: EASY PULSE SENSÖRÜ ILE NABIZ ÖLÇÜMÜ ); http. createserver( onrequest).listen(1337, ,function() console.log("server has started."); ); Bu kod sayesinde script.sh script i içindeki Linux komutunun çıktısı web sunucusu ile yerel ağa verilir. Aynı ağ içerisinde bulunan bir PC ile tarayıcıya yazıldığında sayfada Ben bir Linux scriptiyim yazdığı görülür. Böylece java script kodu içerisinde Linux scripti çağırmayı ve bu script sonucunda ekrana basılan değerin web sunucusu kurulurken kullanılması sağlanmıştır Dakikalık ölçülen nabız değerlerinin web sunucusu ile dışarı verilmesi Deneyin bu aşamasında öğrencilerden EPS ile dakikalık nabız ölçümü alan bir Linux scripti yazmaları (Ekran çıktısı dakikalık nabız değeri olacak) ve bu yazdıkları scriptin java scripti ile çağrılması istenmektedir. Aynı ağdaki bir PC bu web sunucusunu browser ile çağırdığında browserda güncel nabız değeri görülecektir.

25 Bölüm 5 Lab #4: OpenCV Kütüphanesini Kullanarak Resim İşleme Uygulamaları 5.1 Giriş Bu derste öğrencilerin kullanacağı Intel Galileo kartında, image olarak, içinde OpenCV kütüphanesi bulunan bir image SD kartın içinde hazır olarak verilecektir. Derleme işlemeleri Intel Galileo üzerinde yapılacaktır. Intel Galileo kartına USB HOST girişinden WebCam bağlanarak resim kaydetme ve bu resime kenar dedektör filtresi uygulanacaktır Deney Süresi 2 Hafta Deneyin Amaçları 1. Temel resim işleme algoritmaları hakkında bilgi verilmesi 2. Opencv kütüphanesinin nasıl kullanılacağının öğretilmesi Deneyin Kazanımları Linux sisteme USB portundan bir cihaz bağlandığında bu cihazın nasıl takip edileceği öğrenilecek. OpenCV kütüphanesindeki hazır fonksiyonlar hakkında genel bilgi sahibi olunacak ve OpenCV kütüphanesindeki foksiyonlar kullanılarak yazılan bir kodun nasıl derleneceği gösterilecek. Resim üzerinde kenar dedektörü filtresinin etkisi öğrenilecek Gerekli Ön Bilgiler Bu deneyde OpenCV kütüphanesi kullanılacaktır yılında Intel tarafından geliştirilmeye başlanılan bu kütüphane, görüntü işleme ile alakalı 500 den fazla optimize edilmiş fonksiyon içermektedir. Bu kütüphane sayesinde kenar dedektörü, arka plan çıkartma gibi fonksiyonlar yanında webcam den görüntü alma gibi işlemler de kolaylıkla yapılabilmektedir. OpenCV kütüphanesi ile ilgili olarak daha detaylı bilgi için aşağıdaki linkte verilen site ziyaret edilebilir: Materyaller ve Kaynaklar Intel Galileo geliştirme kartı Webcam USB OTG Kablosu 25

26 26 BÖLÜM 5. LAB #4: OPENCV KÜTÜPHANESINI KULLANARAK RESIM İŞLEME UYGULAMALARI OpenCV kütüphanesi için kaynak : Intel Academic Software sitesinden alinan kaynak kodun bulunduğu döküman : InternetOfThings/IntelAcademic_IoT_08_OpenCV.pdf 5.2 Deneyin İşlenişi OpenCV kütüphanesi Intel Galileo geliştirme kartına önceki deneylerde gösterildiği şekilde SSH protokolü ile bağlanılır. Aşağıdaki komutlar ile Home klasörüne gidilir ve bu klasör içerisinde Opencv diye bir klasör açılır. # cd /Home # mkdir opencv Opencv klasörünün içine daha önceden image de hazır olarak verilmiş olan resim dosyası image1.jpeg (Şekil 5.1) kopyalanır. # cp /Home/image1.jpeg /Home/Opencv Aşağıdaki komutla vi editörü bir C++ kodu oluşturmak için açılır. # vi opencvdeneme.cpp Buraya aşağıda hazır olarak verilen C++ kodu yazılır. #include <cv.h> #include <highgui.h> using namespace cv; int main( int argc, char** argv ) char* imagename = argv[1]; Mat image; image = imread( imagename, 1 ); if( argc!= 2!image.data ) printf( " No image data \n " ); return -1; Mat gray_image; cvtcolor( image, gray_image, CV_BGR2GRAY ); imwrite( "result.jpg", gray_image ); return 0; Bu kod verilen resmi gri seviyeye çevirmek için yazılmıştır (Intel Academic Software sitesinden alındı). Bu dosya kaydedilir ve aşağıdaki komut ile derlenir. # g++ opencvdeneme.cpp pkg-config opencv cfags -libs -o opencvdeneme Daha sonra derlenen program aşağıdaki komut ile çalıştırılır. #./opencvdeneme Sonuç olarak result.jpg (Şekil 5.2) adında bir resim dosyası oluşur. Bu resim ve image1 resmi aşağıda verilmiştir. Görüldüğü gibi bu program renkli resmi gri seviye bir resme dönüştürmüştür Webcam in Intel Galileo geliştirme kartına bağlanması USB OTG kablosu ile webcam Intel Galileo geliştirme kartının USB HOST girişine bağlanır. Aşağıdaki komut ile webcamin tanınıp tanınmadığı anlaşılabilir. #dmesg Daha sonra /dev klasörüne bakılır. Eğer webcam bağlanmış ise burada video0, video1 gibi bir dosya oluşması gerek. #ls /dev Bu kontrol de bittikten sonra webcam den görüntü almak için aşağıdaki C++ kodu yazılır.

27 5.2. DENEYIN İŞLENIŞI 27 Şekil 5.1: image1.jpeg Şekil 5.2: result.jpeg #include <iostream > #include <opencv2/opencv.hpp > using namespace std; using namespace cv; int main() VideoCapture capture(1); if(!capture.isopened()) cout << "Failed to connect to the camera." << endl; Mat frame; capture >> frame;

28 28 BÖLÜM 5. LAB #4: OPENCV KÜTÜPHANESINI KULLANARAK RESIM İŞLEME UYGULAMALARI if(frame.empty()) cout << "Failed to capture an image" << endl; return -1; imwrite("capture.png", frame); return 0; Bu kod capture.cpp olarak kaydedilir. Daha sonra bu kod aşağıdaki komut ile derlenir. # g++ capture.cpp pkg-config opencv cfags -libs -o capture Daha sonra bu program çalıştırıldığında ilk resmimizi kaydetmiş oluruz. Resme aynı klasör içerisindeki capture.png (Şekil 5.3) dosyasından ulaşabiliriz. #./capture Şekil 5.3: capture.png Bir Kenar Dedektörü Algoritmasının Gerçeklenmesi Bu aşamada öğrencilerden OpenCV kütüphanesini kullanarak Canny Edge dedektörü algoritması ile kameradan alınan resmin kenarları ayrı bir resme kaydedilmesi istenir. Program çıktı olarak iki resim verecektir. Birincisi kameradan alınan resim capture.png (Şekil 5.3), ikincisi bu resmin kenarları edges.png (Şekil 5.4) olacaktır.

29 5.2. DENEYIN İŞLENIŞI 29 Şekil 5.4: edges.png

30 30 BÖLÜM 5. LAB #4: OPENCV KÜTÜPHANESINI KULLANARAK RESIM İŞLEME UYGULAMALARI

31 Bölüm 6 Lab #5: Pololu Servo Sürücüsü ile Servo Motor Kontrolü 6.1 Giriş Bu deneyde Pololu servo kontrolör kullanılarak bir servo motoru kontrol edilecektir. Deney sonucunda kullanılan servo motorun hedef pozisyonu, hız ve ivme ayarları yapılacaktır Deney Süresi 2 Hafta Deney Amaçları 1. Pololu servo sürücüsünün bağlanması ve kurulumunun incelenmesi 2. libusb kullanımı hakkında bilgi verilmesi 3. Servo motorun hedef pozisyonu, hız ve ivme ayarlamalarının yapılması Deney Kazanımları USB host portu ile bağlantılı aygıtların libusb ile ele alınması öğrenilecektir Gerekli Ön Bilgiler Pololu micro maestro usb servo sürücüsü, çok kullanışlı bir servo sürücüsüdür. Bu sürücü 3 farklı control metodu kullanabilir: 1. USB ile direk PC den kontrol 2. TTL seviyesinde seri haberleşme ile gömülü sistemler ile kontrol 3. Kendi denetleyicisi üzerinde koşturulan script ile kendi kendine kontrol Kanallar RC servolar ve Elektronik hız kontrolleri tarafından kullanılan servo çıkışları olarak ayarlanabilir. Bu deneyde Intel Galileo geliştirme kartının USB portu ve Pololu servo sürücüsünün USB portundan kontrol metodu kullanılarak bir servo motorunun pozisyon hız ve ivme kontrolleri gerçekleştirilecektir. Deneyden kullanılan servo sürücüsü ile ilgili daha detaylı bilgi almak için aşağıdaki linkte verilen sayfa ziyaret edilebilir: 31

32 32 BÖLÜM 6. LAB #5: POLOLU SERVO SÜRÜCÜSÜ ILE SERVO MOTOR KONTROLÜ Materyaller ve Kaynaklar Intel Galileo geliştirme kartı Pololu micro maestro 6-kanal usb servo sürücüsü ve 1 servo motor, libusb ( 6.2 Deneyin İşlenişi Kart 5V luk harici beslemesinden güç kaynağına bağlanır ve USB LED yanana kadar beklenir. USB kablosu, USB HOST portuna bağlanır. Pololu servo sürücüsü ise USB nin diğer ucuna bağlanır. SSH ile karta bağlanılır. cat /sys/kernel/debug/usb/devices komutu çalıştırılır. Bu komut ile ürün ismi görülmesi gerekir. Ürün ID sine dikkat edilmesi gerekir USB ile libusb haberleşmesi libusb: Çok elverişli bir kütüphanedir ve programdaki USB desteğini aktif hale getirir. C++ ve diğer yaygın programlama dilleri için kullanılabilir. Aşağıda verilen genel kod kütüphanenin nasıl kullanılacağını göstermektedir: #include <libusb -1.0/ libusb.h> // Kütüphane başlık dosyaları çağırılır. using namespace std; int main(int argc, char *argv[]) libusb_device ** devs; // USB aygıtlarını kapsar. libusb_context *ctx = NULL; // USB içeriğini kapsar. libusb_device_descriptor descr; // Aygıt açıklayıcı dosyasını kapsar. // haberleşmek istenen USB aygıtı işaretçisi libusb_device *mydevice; int r; // hata ayıklamak için hata kodunu elde etmek ssize_t cnt; // tespit edilen USB aygıtlarının sayısı r= libusb_init(& ctx); // USB haberleşmesinin başlaması libusb_set_debug(ctx, 3); // hata ayıklama seviyesini ayarla cnt = libusb_get_device_list(ctx, &devs); // aygıt listesini al int found = 0; // istenilen aygıtın bulunduğuna dair mantıksal değer ssize_t i; for(i = 0; i < cnt; i++) // Her aygıt için açıklayıcı dosya okunur r = libusb_get_device_descriptor(devs[i],& descr); if(descr. idproduct == XXX) // istenilen ürün numarası ise mydevice = (devs[i]); //bu aygıtı muhafaza et found = 1; break; libusb_unref_device(devs[i]); // aygıt listesi, açıklayıcılara erişim için serbest tahsis edilen bellek if(found) // USB kanalları ve bitiş noktaları için işleyici tablosu libusb_device_handle ** handle; // Aygıtın açılması r = libusb_open(mydevice,handle); // Linux çekirdeğinin USB aygıtını kullnmaya çalışmadığından emin olmak için. r = libusb_detach_kernel_driver(* handle,0); if(r < 0 && r!= LIBUSB_ERROR_NOT_FOUND) cout <<"Error: detach kernel driver failed"<<endl; return 1 ;

33 6.2. DENEYIN İŞLENIŞI 33 // Sisteme USB arayüzünün yönetileceği söylenmektedir. r = libusb_claim_interface(* handle,0); // Bir iş eklemek // Örneğin bir kontrol transferi gerçekleştirilmesi r = libusb_control_transfer (...); // arayüzü iş bittiğinde serbest bırakmak r = libusb_release_interface(* handle,0); // USB kanalını kapat libusb_close(* handle); // tahsis edilen belleği, aygıt listesini ve USB içeriğini boşaltmak libusb_free_device_list(devs, 1); libusb_exit(ctx); // Program sonu return 0; Pololu Servo sürücüsünün USB ile kontrolü 3 farklı program Pololu servo sürücüsünün, USB kanalı açıp bu kanal üzerinden kontrol transferi gerçekleştirip ve kanalı kapatması işini yaptırır. Bu 3 program servo motorun hedef pozisyonunun, hızının ve ivmesinin kurulum işlemlerini gerçekleştirir. 1. Kod: Set_target.cpp #include <iostream > #include <string > #include <libusb -1.0/ libusb.h> #include <unistd.h> #include <stdlib.h> using namespace std; int main(int argc, char *argv[]) if(argc < 3) cout << "Usage: binary servo_number target_value" << endl; int servo = atoi(argv[1]); // _Ilk parametre servo kanal numarasını verir. int value = atoi(argv[2]); // _Ikinci parametre servo kanal değerini verir. libusb_device ** devs; libusb_context *ctx = NULL; libusb_device_descriptor descr; libusb_device *pololu; int r; int found = 0; ssize_t cnt; r = libusb_init(& ctx); libusb_set_debug(ctx, 3); cnt = libusb_get_device_list(ctx, &devs); ssize_t i; for(i = 0; i < cnt; i++) r = libusb_get_device_descriptor(devs[i],& descr); if(descr. idproduct == 137) // Ürün ID bilgisini gösterir. // Ondalık veya onaltılık sayı düzeninde gösterilebilir. pololu = (devs[i]); found = 1; break; libusb_unref_device(devs[i]); if(found) libusb_device_handle ** handle; r = libusb_open(pololu,handle); r = libusb_detach_kernel_driver(* handle,0); if(r < 0 && r!= LIBUSB_ERROR_NOT_FOUND)

34 34 BÖLÜM 6. LAB #5: POLOLU SERVO SÜRÜCÜSÜ ILE SERVO MOTOR KONTROLÜ cout <<"Error: detach kernel driver failed"<<endl; return 1; r = libusb_claim_interface(* handle,0); // pozisyon ayarlama r = libusb_control_transfer( *handle 0x40, // talep tipi 0x85, //talep value, //değer servo, // servo numarası NULL, 0, 5000 ); //0x85 hedef pozisyonu ayarlamak için talep edilir. r = libusb_release_interface(* handle,0); libusb_close(* handle); libusb_free_device_list(devs, 1); libusb_exit(ctx); return 0; 2. Kod açıklamaları: Set accel and Set speed Diğer iki program için, set target.cpp dosyası, set accel.cpp, set speed.cpp kopyalanır. Kontrol transfer fonksiyon çağrısı bu fonksiyonlar ile değiştirilir. Set_accel r = libusb_control_transfer( *handle, 0x40, Set_speed r = libusb_control_transfer( *handle, 0x40, 3. Derleme ve çalıştırma: libusb ile derlemek için gömülü GCC komutu: g++ set_target.cpp pkg -config --libs libusb o set_target g++ set_speed.cpp pkg -config --libs libusb o set_speed g++ set_accel.cpp pkg -config --libs libusb o set_accel Çapraz derleme yazılım dizisi zinciri (cross compile toolchain) ile derleme \$CXX set_target.cpp pkg -config --libs libusb o set_target İkili veri dosyası karta gönderilir. Program çalıştırıldığında; Hedef pozisyonu 1500 mikrosaniyeye kurmak için 4 ile çarpılır. Kanal no (servo) 3 ayarlanır..set target Hız değeri servo no 1 de minimuma ayarlanır..set speed x84, value, servo 0 x80, NULL,0,5000) ; 0x84, value, servo, NULL,0,5000) ;

35 Bölüm 7 Lab #6: Xylaphone 7.1 Giriş Bu deneyde ADC kullanılarak Intel Galileo kart üzerinde MIDI çıktı dosyaları üretilecektir Deney Süresi 2 Hafta Deneyin Amaçları 1. ADC den gelen verilerin okunması 2. 6 farklı notanın Intel Galileo ADC lerinden gelen veriler ile üretilmesi Deneyin Kazanımları Intel Galileo geliştirme kartında analog sayısal dönüştürücü (ADC) kullanımı MIDI (Müzikal Enstürman Sayısal Arayüz) çıktı dosyasının Intel Galileo tarafından oluşturulması Gerekli Ön Bilgiler Bu deneyde diğer deneylerin aksine Ardunio IDE kullanılarak Intel Galileo Kartı ile uygulama geliştirilecektir. Bunun için Ardunio da seri haberleşme, ADC kullanımı hakkında genel bir bilgiye sahip olmak gerekmektedir. Kaynak olarak aşağıdaki linkte verilen siteden faydalanılabilir: Materyaller ve Kaynaklar Intel Galileo geliştirme kartı MIDI kaynak kodu ( MIDI-seri işaret çevirici ( GarageBand ses kayıt programı ( Xylophone Ardunio Programlama hakkından bilgi için Gerekli elektronik materyaller: (x12) Piezo Elemanları (x12) 1M Ohm dienç 35

36 36 BÖLÜM 7. LAB #6: XYLAPHONE (x1) Tek şeritli kablo (x1) Devre maketi (Breadboard) (x1) USB 2.0 kablosu Kablo sarma bandı (Electrical Tape) Kablo ucu kılıfı (Heat shrink) 7.2 Deneyin İşlenişi Intel Galileo geliştirme kartının üzerindeki analog girişlere Xylophone da numaralandırılan A0 dan A5 e kadar olan girişler bağlanır. (a) (b) Şekil 7.1: Piezo elemanlarının dirençler ile bağlantısı Arduino programı çalıştrılır. Programın amacı MIDI işaretleri oluşturmaktır. Müzik Enstrümanları Dijital Arabirimi ya da kısaca MIDI (Musical Instrument Digital Interface), elektronik müzikaletleri ve bilgisayarlar arasında gerçek zamanlı veri alışverişini sağlayan, endüstri standardı haline gelmiş yaygın biriletişim protokolüdür. Kodun ilk kısmı analog sayısal çevirici girişleri pinleri, nota, çalma zamanı, kanal ayarı yapılır. Seri iletişim hızı belirlenir. Ana programdaki döngülerde MIDI mesajları üretilir ve son kısımda ise üretilen mesajlar seri porttan gönderilir. Aşağıda verilen kod midi.ino olarak klasör içerisine kaydedilir. // Xylophone //********************************************************************* // Kullanıcı ayarlanabilir değişkenleri //******************************************************************* int pinread; char pinassignments [6] = A0, A1, A2, A3, A4, A5 ; byte PadNote [16] = 57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72; // 0 dan 127 ye MIDI (Mid C = 60)

37 7.2. DENEYIN İŞLENIŞI 37 int PadCutOff [16] = 400,400,200,800,400,400,400,400,400,400,400,400,400,400,400,400; // Minumum Analog değerleri int MaxPlayTime [16] = 90,90,90,90,90,90,90,90,90,90,90,90,90,90,90,90; // 2. vuruyu izin verilmeden önceki döngüler #define midichannel 1; // MIDI kanalı 0 dan 15 e (+1 "real world") boolean VelocityFlag = true; // Hız ON (true) veya OFF (false) //********************************************************************* // Ara Değişkenler //********************************************************************* boolean activepad [16] = 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0; //Şu an oynayan padlere ait bayrakların dizisi int PinPlayTime [16] = 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0; // Pad oynamaya başladığı için sayıcı lazım byte status1; int pin = 0; int hitavg = 0; //********************************************************************* // Setup //********************************************************************* void setup() Serial.begin (57600); // Veri iletişim hızı ayarı //********************************************************************* // Ana Program //********************************************************************* void loop() for(int pin=0; pin < 16; pin++) // int pin = 3; // for (pinread=0; pinread < 16, pin++) hitavg = analogread( pinassignments[pin]); // Serial.println(hitavg); // Giriş pinini oku if(( hitavg > PadCutOff[pin])) if(( activepad[pin] == false)) if( VelocityFlag == true) // hitavg = 127 / (( PadCutOff[pin]) / (hitavg - PadCutOff[pin])); hitavg = (hitavg / 8) -1 ; // Üst aralık else hitavg = 127; MIDI_TX(144, PadNote[pin],hitavg); // Note açık PinPlayTime[pin] = 0; activepad[pin] = true; else PinPlayTime[pin] = PinPlayTime[pin] + 1; else if(( activepad[pin] == true)) PinPlayTime[pin] = PinPlayTime[pin] + 1; if( PinPlayTime[pin] > MaxPlayTime[pin]) activepad[pin] = false; MIDI_TX(144, PadNote[pin],0); //*********************************************************************

38 38 BÖLÜM 7. LAB #6: XYLAPHONE // MIDI mesajlarının iletimi //********************************************************************* void MIDI_TX(byte MESSAGE, byte PITCH, byte VELOCITY) status1 = MESSAGE + midichannel; Serial.write(status1); Serial.write(PITCH); Serial.write( VELOCITY); Kod derlenir ve Intel Galileo geliştirme kartına gömülür. Xylophone USB kablosu ile bilgisayardan beslemesi yapılır. Hairless yazılımı ile Intel Galileo kartından gelen seri çıkışlar MIDI işaretlerine dönüştürülür. Dikkat edilmesi gereken nokta Intel Galileo kartı Hairless yazılımına bağlı iken programlanamaz bu yüzden seri port bu yazılım tarafından kullanılmaktadır. Garage- Band, Logic, ve Ableton gibi programlar Hairless yazılımı tarafından üretilen işaretleri okuyup kaydeder. Bu işlemden sonra xylophone bateri gibi çalınabilir. Hairless yazılımı ile Intel Galileo kartından gelen seri çıkışlar MIDI işaretlerine dönüştürülür. GarageBand, Logic, ve Ableton gibi programlar bu işaretleri okuyup kaydeder. Bu işlemden sonra xylophone bateri gibi çalınabilir. Şekil 7.2: Hairless yazılımı

39 7.2. DENEYIN İŞLENIŞI 39 Şekil 7.3: Xylophone-PC ekran görünümü Şekil 7.4: GarageBand programı ekran görünümü