Keyestudio Ultimate Starter Kit for Raspberry Pi {{:rpistarterkit:p0_01.jpg?400|}} =====Bevezetés===== A Raspberry Pi egy apró számítógép. Ez a Raspberry Pi egy indító készlet, amely alkalmas a nulláról való kezdéshez. Ezzel a készlettel többet tudhat meg a Linux operációs rendszer ismereteiről, valamint a C, python és más programozási nyelvről a Raspberry Pi rendszerén keresztül. Ez a készlet néhány, a Raspberry Pi-hez kapcsolódó érzékelőt és modult tartalmaz. Rengeteg tanulási anyagokat kínálunk, amelyek lehetővé teszik, hogy a semmiből tanulja meg a Pi használatát. A tanulási anyagok közé tartozik a Raspberry Pi kapcsolódó rendszer telepítése és használata, amelyeket néhány általánosan használt érzékelővel és modullal kötünk össze. ---- =====RaspberryPi operációs rendszer telepítése===== https://www.raspberrypi.org/downloads/ Első lépésként látogassuk meg ezt az oldalt, ahonnan lehetőségünk nyílik letölteni a Raspberry operációs rendszerét. Itt választhatjuk, hogy a NOOBS vagy a Raspbian verziót töltjük le. A NOOBS a legegyszerű, csak letöltjük és a fájlokat felmásoljuk egy SD kártyára ami 8GB vagy nagyobb méretű. Ezután Ha behelyeztük a kártyát a Raspberry-be a képernyőn megjelenő utasításokat követve nagyon egyszerűen végrehajtható a telepítés. Mi ezt a telepítési módot ajánljuk azoknak akik ezelőtt még soha nem használtak ilyen eszközt. A Raspbian-t azoknak ajánljuk akik már gyakorlottabbak Linux rendszerek telepítésében, használatában. ---- =====Putty telepítése, használata===== https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html A Putty egy távoli hozzáférést biztosító program, amivel könnyedén el tudjuk érni az internetre csatlakozó eszközünket. A program teljesen ingyenes és a fenti linkről letölthető. Telepítés után indítsuk el a programot, ha minden rendben ment ezt a képet kell látnunk. {{ :rpistarterkit:01.png? |}} A Host Name-hez a Raspberry IP-címét kell írni. Amennyiben nem tudja mi az, a Raspberry termináljában lekérdezhető, vagy a router ip kiosztásából kikereshető. A Terminál ablakból a "hostname -I" paranccsal tudjuk lekérdezni, az IP címet. Ez az egyszerűbb megoldás, de a routerben is megtalálható az IP cím. {{ :rpistarterkit:02.png? |}} Írjuk be az IP-címet a Host Name-hez, amennyiben sokszor fogjuk használni ajánlott elmenteni, így legközelebb nem kell beírni a címet, csak az elmentett beállítást betölteni, és használni. Ha megadtuk, kattintsunk az "Open" gombra. {{ :rpistarterkit:03.png? |}} Ekkor ha nem kapunk hibát, megjelenik egy bejelentkező felület. Az alapértelmezett felhasználónév a "pi" és a jelszó "raspberry" ezek az alap beállítások. Amennyiben hibát kapunk kétféle megoldás lehetséges. * Első, hogy elgépeltük az IP-címet. * Második, a Raspberry ssh-ja nem működik megfelelően. Ezt úgy lehet orvosolni, hogy újra indítjuk azt, egy terminálból indított paranccsal: "sudo service ssh restart" Ha ezekkel nem javul meg a probléma keresse fel rendszergazdáját, vagy szolgáltatóját. Bejelentkezés után, ezt a képet kell kapnunk. {{ :rpistarterkit:04.png? |}} ---- =====Fájlok futtathatóvá tétele===== Ahhoz, hogy tudjuk futtatni az elkészült fájljainkat pár apró paranccsal telepíteni kell egy modult. Írjuk be a következőket * **sudo apt-get install git-core** Ezzel telepítjük a git-core nevű alkalmazást * **sudo apt-get update** * **sudo apt-get upgrade** Az újonnan telepített programnak lehet vannak frissítései, az update és az upgrade parancsal ezeket hajtjuk végre. * git clone git://git.drogon.net/wiringPi Ezek után lemásoljuk egy a githubon lévő mappát, a fenti paranccsal. * **cd wiringPi** * **git pull origin** Belelépünk a mappába, majd frissítjük, ha van rá lehetőség. * **./build** Végül telepítjük a letöltött fájlokat. ---- =====1. Projekt, Hello Világ!===== Legelső projektünkben nincs másra szükségünk mint a konzolra. Egy egyszerű "Hello Világ!" feliratot fogunk kiíratni.Első lépésként hozzunk létre egy mappát a fájljainknak, a kavarodások elkerülése végett. Mappa létrehozásának lépései: Futtassuk a következő parancsot: * **sudo mkdir starterkit/** {{ :rpistarterkit:05.png? |}} Ha nem kapunk semmi üzenetet azt jelenti létrehozta a mappát Majd a mappába való belépéshez * **cd starterkit/** {{ :rpistarterkit:06.png? |}} És már a mappában is vagyunk, az elkövetkezendő időben folyamatosan itt fogunk dolgozni, minden fájlt ide fogunk létrehozni. Következő lépésként létre kell hozni, egy fájlt amibe dolgozni fogunk. A szerkesztéshez a Nano beépített szerkesztőt fogjuk használni, de aki ismer nyugodtan használhat másfajta szerkesztőt. * **sudo nano hellovilag.c** {{ :rpistarterkit:07.png? |}} A következő C nyelvű kódot írjuk bele a fájlba vagy másoljuk bele. A másolás úgy történik, hogy kijelöljük és másoljuk a kódot, majd a Nano-ba egyszerű jobb egér gomb lenyomásával beillesztjük oda ahol a kurzor villog.

#include <wiringPi.h>
#include <stdio.h>

int main()

{
  wiringPiSetup();


 for(;;)
 {
 printf("Hello Vilag!\n");
 delay(1000);

 }
}

{{ :rpistarterkit:08.png? |}} A mentés folyamata a következő: - Nyomjuk le a Ctrl+X kombinációt - Megkérdezi, hogy menti-e a módosított fájlt. Erre I/N a válasz, jelen esetben I. - Megkérdezi, hogy milyen néven mentse el a fájlt. Ha csak Entert nyomunk az eredeti nevén menti el, ellenkező esetben nyugodtan át lehet írni a fájl nevét. Ahhoz, hogy tudjuk futtatni a fájlunkat még egy parancsot végre kell hajtani. Ezt minden módosítás után meg kell tenni. Ez egy fordító folyamat ami a mi kódunkat lefordítja gépi nyelvre, hogy a Raspberry is megértse a kódot. * **sudo gcc hellovilag.c -o hellovilag -lwiringPi** {{ :rpistarterkit:09.png? |}} Végül nézzük meg mi lett az eredmény, futtassuk a fájlt a következő képen. * **./hellovilag** {{ :rpistarterkit:10.png? |}} {{ :rpistarterkit:11.png? |}} A programot a Ctrl+C kombinációval tudjuk megszakítani. ---- =====2. Projekt, LED Villogtatása===== **Bevezetés** Ebben a projektben egy LED-et fogunk villogtatni, nagyon egyszerű módon. **Eszközszükséglet** * 1 db piros LED * Ellenállás * RPI GPIO kártya * 40 PIN-es Jumper Kábel * Vezetékek* * USB kábel* * Raspberry Pi* *Ez csak kivételesen lett feltüntetve, a jövőben nem fog megjelenni az Eszközszükségletnél **Eszközök csatlakoztatása** A képre kattintva megtekinthető nagyobb méretbe! {{ :rpistarterkit:p2_01.png? |}} **Programozás** Lépjünk be a már létrehozott "starterkit" nevű mappánkba. * **cd starterkit/** Itt hozzunk létre egy új fájlt **ledvillogtatas.c** néven. * **sudo nano ledvillogtatas.c** {{ :rpistarterkit:p2_02.png? |}} Írjuk, vagy másoljuk be az alábbi kódot, ebbe a fájlba majd mentsük el az első projektben alkalmazott módon.

#include <wiringPi.h>

int main()
{
  wiringPiSetup();

  {
        pinMode(1,OUTPUT);
  }
  
  while(1)
  { 
        digitalWrite(1,HIGH);
        delay(500);
        digitalWrite(1,LOW);
        delay(500);	  
  }
	
}

{{ :rpistarterkit:p2_03.png? |}} A mentés folyamata a következő: * Nyomjuk le a Ctrl+X kombinációt * Megkérdezi, hogy menti-e a módosított fájlt. Erre I/N a válasz, jelen esetben I. * Megkérdezi, hogy milyen néven mentse el a fájlt. Ha csak Entert nyomunk az eredeti nevén menti el, ellenkező esetben nyugodtan át lehet írni a fájl nevét. Ezután készítenünk kell egy futtatható fájlt a C nyelvű fájlunkból. Ezt az előzőekben megismert GCC parancsal fogjuk végrehajtani. * **sudo gcc ledvillogtatas.c -o ledvillogtatas -lwiringPi** {{ :rpistarterkit:p2_04.png? |}} A fájl futtatása után, ha mindent helyesen kötöttünk be, a LED elkezd villogni. * **./ledvillogtatas** {{ :rpistarterkit:p2_05.png? |}} A folyamat megszakításához nyomjuk le a Ctrl+C kombinációt. ---- =====3. Projekt, LED Légzés effektus===== **Bevezetés** Az előző projektben szabályoztuk a LED villogását úgy, hogy magas és alacsony jelet adtunk neki I/O porton keresztül. Ezúttal egy LED fény fényerejét fogjuk szabályozni. **Eszközszükséglet** * 1 db piros LED * Ellenállás **Eszközök csatlakoztatása** A képre kattintva megtekinthető nagyobb méretben. {{ :rpistarterkit:p2_01.png? |}} **Programozás** Először is hozzunk létre egy új C fájlt amibe a programunkat írni fogjuk. * **sudo nano legzeseffekt.c** {{ :rpistarterkit:p3_01.png |}} A következő kódot írjuk a fájlba.

 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <wiringPi.h>
 #define LED 1

int main(void)
{
   int bright;
    printf("Raspberry Pi wiringPi PWM test program\n");
    if (wiringPiSetup() == -1)
     {
        printf("GPIO setup error!\n");
         exit(1);
    }
    pinMode(LED,PWM_OUTPUT);
     while(1)
    {
     for (bright = 0; bright < 1024; ++bright)
         {
            pwmWrite(LED,bright);
            printf("bright:%d\n",bright);
             delay(3);
        }
    for (bright = 1023; bright >= 0; --bright)
        {
             pwmWrite(LED,bright);
             printf("bright:%d\n",bright);
             delay(3);
         }
       }
     return 0;
 }

{{ :rpistarterkit:p3_02.png |}} Ezután tegyük futtathatóvá a fájlt a már eddig is használt GCC paranccsal. * **sudo gcc legzeseffekt.c -o legzeseffekt -lwiringPi** {{ :rpistarterkit:p3_03.png |}} Végül futtassuk a programot sudo paranccsal. Ha mindent jól csináltunk akkor a LED lassan felgyúl majd elalszik. * **sudo ./legzeseffekt** {{ :rpistarterkit:p3_04.png |}} A program megállítása a már ismert Ctrl+C gomb kombinációval lehetséges. ---- =====4. Projekt, Közlekedési lámpa===== **Bevezetés** Ez a projekt a 2. alapján van kidolgozva, Itt 3 LED-et fogunk villogtatni megadott időközönként, ezzel elérve, hogy egy közlekedési lámpát szimuláljunk. **Eszközszükséglet** * 1 db piros LED * 1 db sárga LED * 1 db kék LED * 3 db ellenállás **Eszközök csatlakoztatása** A képre kattintva megtekinthető nagyobb méretben. {{ :rpistarterkit:p4_01.png |}} **Programozás** Először hozzunk létre egy új C fájlt **kozlekedesilampa.c** néven. * **sudo nano kozlekedesilampa.c** {{ :rpistarterkit:p4_02.png |}} Írjuk bele a következő kódot a fájlba. Majd mentsük el azt. Amennyiben nem tudja vagy nem emlékszik rá, hogyan kell, görgessen vissza az első projekthez.

#include <wiringPi.h>

int main()
{
  wiringPiSetup();
  char i;
  char j;
  for(i=1;i<4;i++)
  {
        pinMode(i,OUTPUT);
  }
  while(1)
  { 
   digitalWrite(1, HIGH);//// turn on blue LED
   delay(5000);// wait 5 seconds
   digitalWrite(1, LOW); // turn off blue LED
   for(j=0;j<3;j++) // blinks for 3 times
   {
   delay(500);// wait 0.5 second
   digitalWrite(2, HIGH);// turn on yellow LED
   delay(500);// wait 0.5 second
   digitalWrite(2, LOW);// turn off yellow LED
   } 
   delay(500);// wait 0.5 second
   digitalWrite(3, HIGH);// turn on red LED
   delay(5000);// wait 5 second
   digitalWrite(3, LOW);// turn off red LED
   } 
}

{{ :rpistarterkit:p4_03.png |}} Mentés után, tegyük futtathatóvá a kódunkat GCC paranccsal. Amennyiben nem tudja vagy nem emlékszik rá, hogyan kell, görgessen vissza az első projekthez. * **sudo gcc kozlekedesilampa.c -o kozlekedesilampa -lwiringPi** {{ :rpistarterkit:p4_04.png |}} Majd futtassuk a programot sudo-ként. * **sudo ./kozlekedesilampa** {{ :rpistarterkit:p4_05.png |}} ---- =====5. Projekt, Futó fény effekt===== **Bevezetés** Ebben a projektben is LED-eket fogunk villogtatni, ám most egy futó fény effektust próbálunk elérni. Ennél is alapul vesszük amit a 2. projektben tanultunk. **Eszközszükséglet** * 3 db piros LED * 3 db Ellenállás **Eszközök csatlakoztatása** A képre kattintva megtekinthető nagyobb méretben. {{ :rpistarterkit:p5_01.png |}} **Programozás** Hozzunk létre egy új fájlt **futofeny.c** néven. * **sudo nano futofeny.c** {{ :rpistarterkit:p5_02.png |}} Írjuk bele az alábbi kódot.

#include <wiringPi.h>

int main()
{
  wiringPiSetup();
  char i;
  for(i=1;i<4;i++)
  {
    pinMode(i,OUTPUT);
  }
  
  while(1)
  {  
    for (i=1;i<4;i ++) 
   {
    digitalWrite(i, LOW);// set I/O pins as “low”
     delay(200);        // delay
   }
   for (i=1;i<4;i ++) 
   {
     digitalWrite(i, HIGH);// set I/O pins as “high”
     delay(200);       // delay
   } 
  }    
}

{{ :rpistarterkit:p5_03.png |}} Ezek után tegyük futtathatóvá a fájlunkat a már ismert GCC paranccsal. * **sudo gcc futofeny.c -o futofeny -lwiringPi** {{ :rpistarterkit:p5_04.png |}} Végül futtassuk a programot. Ha mindent jól csináltunk, a LED-ek futó fény effektusát alkotják majd. * **sudo ./futofeny** {{ :rpistarterkit:p5_05.png |}} ---- =====6. Projekt, Gombbal irányítható LED===== **Bevezetés** Ebben a projektben az eddigiektől eltérően, nem csak OUTPUT, kimenetet fogunk használni, hanem egy INPUT, bemenetet is. Egy gomb lenyomására küldünk egy jelet a Raspberry-nek, ami azt feldolgozva felkapcsolja a LED-et. **Eszközszükséglet** * 1 db piros LED * 220Ω Ellenállás * 1 db nyomógomb * 10KΩ Ellenállás **Eszközök csatlakoztatása** A képre kattintva megtekinthető nagyobb méretben. {{ :rpistarterkit:p6_01.png |}} **Programozás** Először hozzunk létre egy új fájlt **gombled.c** néven. * **sudo nano gombled.c** {{ :rpistarterkit:p6_02.png |}} Írjuk a fájlba a következő C nyelvű kódot.

#include <wiringPi.h>

int main()
{
  wiringPiSetup();
  char val;
  {
    pinMode(1,INPUT);
    pinMode(2,OUTPUT);
  } 
  while(1)
  { 
   val=digitalRead(1);
   if(val==1)//check if the button is pressed, if yes, turn on the LED
   digitalWrite(2,LOW);
   else
   digitalWrite(2,HIGH);
  }	
}

{{ :rpistarterkit:p6_03.png |}} Ezek után tegyük futtathatóvá a fájlunkat a már jól ismert GCC paranccsal. * **sudo gcc gombled.c -o gombled -lwiringPi** {{ :rpistarterkit:p6_04.png |}} Végül pedig futtassuk a programot, ha mindent jól csináltunk a gomb megnyomására a LED felvillan. * **./gombled** {{ :rpistarterkit:p6_05.png |}} ---- =====7. Projekt, Passzív csipogó===== **Bevezetés** Amikor Raspberry-vel foglalkozunk számos interaktív dolgot tudunk csinálni vele, ezekhez leggyakrabban hangot és fényt használunk. Az előzőekben fényeket villogtattunk, mostani kísérletben hangot fogunk generálni. Egy passzív csipogó segítségével, négyzethullámokat generálunk (0-1 érték) és ezek által fog megszólalni a csipogónk. **Fontos**, hogy létezik aktív csipogó és passzív csipogó. A kettő közötti különbség az, hogy az aktív hangjelző beépített oszcilláló forrással rendelkezik, így elektromosság hatására hangot generál. Az ebben a modulban használt csipogó passzív csipogó . A passzív csipogónak nincs ilyen forrása, így a DC jellel nem képes sípolni. Ehelyett négyzethullámokat kell használnia, amelyek frekvenciája 2K és 5K között. A különböző frekvenciák különböző hangokat adnak. **Eszközszükséglet** * 1 db passzív csipogó **Eszközök csatlakoztatása** A képre kattintva megtekinthető nagyobb méretben. {{ :rpistarterkit:p7_01.png |}} **Programozás** Elsőként hozzunk létre egy új fájlt **passzivcsipogo.c** néven. * **sudo nano passzivcsipogo.c** {{ :rpistarterkit:p7_02.png |}} Írjuk bele a következő kódot a fájlba.

#include <wiringPi.h>

int main()
{
  wiringPiSetup();
  char i;
  char j;

  {
    pinMode(1,OUTPUT);
  }  
  while(1)
   { 
    for(i=0;i<80;i++)// output a frequency sound
   { digitalWrite(1,HIGH);// sound
     delay(1);//delay1ms 
     digitalWrite(1,LOW);//not sound
     delay(1);//ms delay 
    } 
   for(j=0;j<100;j++)// output a frequency sound
    { digitalWrite(1,HIGH);// sound
      delay(2);
      digitalWrite(1,LOW);//not sound
      delay(2);//2ms delay 
     }
   } 	  
  }

{{ :rpistarterkit:p7_03.png |}} Mentsük el, majd a GCC paranccsal tegyük futtathatóvá a fájlt * **sudo gcc passzivcsipogo.c -o paszivcsipogo -lwiringPi** {{ :rpistarterkit:p7_03.png |}} Végül futtassuk a fájlt, amennyiben mindent jól csináltunk, a csipogó megszólal. * **sudo ./passzivcsipogo** {{ :rpistarterkit:p7_04.png |}} A programot a Ctrl+C billentyűkombinációval tudjuk leállítani ---- =====8. Projekt, Aktív csipogó===== **Bevezetés** Az előző leckében passzív csipogóval ismerkedtünk meg. Ezúttal az aktív csipogóval fogunk foglalkozni. Az aktív csipogó saját oszcillátorforrással rendelkezik így elég egy magas értéket adni neki, hogy szépen megszólaljon. A kísérletben egyszerűen csak fel és le fogjuk kapcsolni a magas értékeket, de ez tetszés szerint változtatható különböző hangok megszólaltatásához. **Eszközszükséglet** * 1 db aktív csipogó **Eszközök csatlakoztatása** A képre kattintva megtekinthető nagyobb méretben. {{ :rpistarterkit:p8_01.png |}} **Programozás** Elsőként hozzunk létre egy új fájlt **aktivcsipogo.c** néven * **sudo nano aktivcsipogo.c** {{ :rpistarterkit:p8_02.png |}} Ezután írjuk bele a fájlba a következő kódot.

#include <wiringPi.h>
int main()
{
  wiringPiSetup();

  {
        pinMode(1,OUTPUT);
  }
  
  while(1)
  { 
        digitalWrite(1,HIGH);
        delay(1000);
        digitalWrite(1,LOW);
        delay(1000);	  
  }
	
}

{{ :rpistarterkit:p8_03.png |}} Következő lépésként tegyük futtathatóvá a programot a GCC parancs segítségével. * **sudo gcc aktivcsipogo.c -o aktivcsipogo -lwiringPi** {{ :rpistarterkit:p8_04.png |}} Végül futtassuk a programot. * **sudo ./aktivcsipogo** {{ :rpistarterkit:p8_05.png |}} ---- =====9. Projekt, Tűz érzékelő szenzor===== **Bevezetés** Előzőekben már csináltunk gombra világító LED fényt, most ezt egy kicsit át alakítva fogjuk használni. Egy infravörös fény érzékelőt fogunk használni a láng fényének észlelésére. Az érzékelőnk magas illetve alacsony jelet fog adni, a tűz mértékétől függően. Ezt számunkra egy LED helyett most egy csipogó fogja jelezni. Az összefüggés a két kísérlet között, az elmélete. Ugyan az az elmélet, csak az egyik esetben gombot a másikban automata érzékelőt használunk. **Eszközszükséglet** * 1 db Aktív csipogó * 1 db Tűz érzékelő szenzor * 1 db Ellenállás **Eszközök csatlakoztatása** A képre kattintva nagyobb méretben is megtekinthető. {{ :rpistarterkit:p9_01.png |}} **Programozás** Első lépésként hozzunk létre egy új fájlt **tuzerzekelo.c** néven. * **sudo nano tuzerzekelo.c** {{ :rpistarterkit:p9_02.png |}} Ezután írjuk bele a fájlba az alábbi kódot.

#include <wiringPi.h>

int main()
{
  wiringPiSetup();
  char val;
  {
    pinMode(1,INPUT);
    pinMode(2,OUTPUT);
  }
  
  while(1)
  { 
   val=digitalRead(1);
   if(val==1)
   digitalWrite(2,LOW);
   else
   digitalWrite(2,HIGH);
  }	
}

{{ :rpistarterkit:p9_03.png |}} Tegyük futtathatóvá a fájlunkat a GCC parancs segítségével. * **sudo gcc tuzerzekelo.c -o tuzerzekelo -lwiringPi** {{ :rpistarterkit:p9_04.png |}} Végül pedig futtassuk a programot a már ismert módon. * **sudo ./tuzerzekelo** {{ :rpistarterkit:p9_05.png |}} ---- =====10. Projekt, Golyós billentés érzékelő===== **Bevezetés** A golyós billentés érzékelő ugyan azt az elvet használja mint egy sima kapcsoló. Ha a golyó pont középen van akkor vízszintesben van az eszköz tehát nem érintkezik semmivel. Ha megdől az eszköz, a golyó az eszköz valamelyik oldalához hozzá ér, ezzel összeérintve két fém darabot és "kapcsoló" elven átadja az áramot. **Eszközszükséglet** * 1 db Piros LED * 2 db Ellenállás * 1 db Golyós billentés érzékelő **Eszközök csatlakoztatása** A képre kattintva nagyobb méretben is megtekinthető. {{ :rpistarterkit:p10_01.png |}} **Programozás** Első lépésként hozzunk létre egy új fájlt **golyo.c** néven. * **sudo nano golyo.c** {{ :rpistarterkit:p10_02.png |}} Ezután írjuk a fájlba a következő kódot.


#include <wiringPi.h>
int main()
{
  wiringPiSetup();
  char val;
  {
    pinMode(1,INPUT);
    pinMode(2,OUTPUT);
  }
  
  while(1)
  { 
   val=digitalRead(1);
   if(val==1)
   digitalWrite(2,LOW);
   else
   digitalWrite(2,HIGH);
  }	
}

{{ :rpistarterkit:p10_03.png |}} Mentsük el, majd tegyük futtathatóvá a GCC parancs segítségével. * **sudo gcc golyo.c -o golyo -lwiringPi** {{ :rpistarterkit:p10_04.png |}} Végül futtassuk a programot, és próbáljuk ki az eszközt a különböző döntési pozíciókba. * **sudo ./golyo** {{ :rpistarterkit:p10_05.png |}} ---- =====11. Projekt, Infravörös (IR) távirányítás===== **Bevezetés** Az általános IR távvezérlő rendszer két részre osztható: adó és vevő. Ebben a kísérletben a küldő a távirányító lesz, a vevő egy VS1838B infravörös vevő. Ebben a kísérletben, fogadjuk a távirányítóból érkező jeleket és kiíratjuk azt a képernyőre. **Eszközszükséglet** * 1 db IR távirányító * 1 db IR vevőegység **Eszközök csatlakoztatása** A képre kattintva nagyobb méretben is megtekinthető. {{ :rpistarterkit:p11_01.png |}} **Programozás** Először hozzunk létre egy új fájlt **taviranyito.c** néven. * **sudo nano taviranyito.c** {{ :rpistarterkit:p11_02.png |}} Ezután írjuk a fájlba a következő kódot.

#include <wiringPi.h>
#include <stdio.h>
#define PIN 1
#define IO digitalRead(PIN)
unsigned char i,idx,cnt;
unsigned char count;
unsigned char data[4];

int main()
{
    if (wiringPiSetup() < 0)return 1;
    pinMode(PIN, INPUT);
    pullUpDnControl(PIN, PUD_UP);
	printf("IRM Test Program ... \n");

	while (1)
	{	
		if(IO == 0)
		{
			count = 0;
			while(IO == 0 && count++ < 200)   //9ms
		    	delayMicroseconds(60);
			
			count = 0;
			while(IO == 1 && count++ < 80)	  //4.5ms
		    	delayMicroseconds(60);
			
			idx = 0;
			cnt = 0;
			data[0]=0;
			data[1]=0;
			data[2]=0;
			data[3]=0;
			for(i =0;i<32;i++)
			{
				count = 0;
				while(IO == 0 && count++ < 15)  //0.56ms
		    		delayMicroseconds(60);
				
				count = 0;
				while(IO == 1 && count++ < 40)  //0: 0.56ms; 1: 1.69ms
		    		delayMicroseconds(60);

				if (count > 25)data[idx] |= (1<<cnt);
				if(cnt == 7)
				{
					cnt = 0;
					idx++;
				}
				else cnt++;
			}

			if(data[0]+data[1] == 0xFF && data[2]+data[3]==0xFF)	//check	
				printf("Get the key: 0x%02x\n",data[2]);
		}
	}
}

{{ :rpistarterkit:p11_03.png |}} Tegyük futtathatóvá C nyelvű fájlunkat a GCC parancs segítségével. * **sudo gcc taviranyito.c -o taviranyito -lwiringPi** {{ :rpistarterkit:p11_04.png |}} Végül futtassuk a programot, ha mindent jól csináltunk, egy gomb megnyomására megjelenik annak kódolt értéke. * **sudo ./taviranyito** {{ :rpistarterkit:p11_05.png |}} ---- =====12. Projekt, 1 db 7 szegmenses kijelző===== **Bevezetés** A 7 szegmenses kijelző egyfajta félvezető fénykibocsájtó eszköz, amelynek alapegysége egy fény kibocsájtó dióda. Ebben a kísérletben egy egyszerű számlálót fogunk készíteni, úgy hogy a megfelelő szegmenseket fel és le kapcsoljuk a kijelzőn, így elérve, hogy egy szám jelenjen meg. **Eszközszükséglet** * 1 db digitális 7 szegmenses kijelző * 8 db Ellenállás **Eszközök csatlakoztatása** A képre kattintva nagyobb méretben megtekinthető. {{ :rpistarterkit:p12_01.png |}} **Programozás** Elsőként hozzunk létre egy, **hetszegmenses.c** nevű fájlt. * **sudo nano hetszegmenses.c** {{ :rpistarterkit:p12_02.png |}} Írjuk bele a fájlba a következő C nyelvű kódot.


#include <wiringPi.h>

int a=27;//GPIO16
int b=26;//GPIO12
int c=23;//GPIO13
int d=24;//GPIO19
int e=25;//GPIO26
int f=28;// GPIO20
int g=29;//GPIO21
int dp=22;//GPIO6
int i; 
void digital_0()//0
{
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,LOW);
digitalWrite(dp,LOW);
}
void digital_1()//1
{
digitalWrite(a,LOW);
digitalWrite(b,HIGH); 
digitalWrite(c,HIGH); 
digitalWrite(d,LOW);
digitalWrite(e,LOW); 
digitalWrite(f,LOW);
digitalWrite(g,LOW);
digitalWrite(dp,LOW); 
}
void digital_2()//2
{
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,LOW);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,LOW);
digitalWrite(g,HIGH);
digitalWrite(dp,LOW);
}
void digital_3()//3
{
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,HIGH);
digitalWrite(dp,LOW);
}
void digital_4()//4
{
digitalWrite(a,LOW);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
digitalWrite(dp,LOW);
}
void digital_5()//5
{
digitalWrite(a,HIGH);
digitalWrite(b,LOW);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,LOW);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
digitalWrite(dp,LOW);
digitalWrite(e,LOW);
}
void digital_6()//6
{
digitalWrite(a,HIGH);
digitalWrite(b,LOW);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
digitalWrite(dp,LOW);
}
void digital_7()//7
{
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
digitalWrite(dp,LOW);
}
void digital_8()//8
{
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
digitalWrite(dp,LOW);
}
void digital_9()//9
{
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,LOW);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
digitalWrite(dp,LOW);
}
int main()
{
 wiringPiSetup();
{
for(i=22;i<=29;i++)
pinMode(i,OUTPUT); 
 }
 while(1)
  { 
  digital_0();//0
  delay(1000);
  digital_1();//1
  delay(1000);
  digital_2();//2
  delay(1000); 
  digital_3();//3
  delay(1000); 
  digital_4();//4
  delay(1000); 
  digital_5();//5
  delay(1000); 
  digital_6();//6
  delay(1000); 
  digital_7();//7
  delay(1000); 
  digital_8();//8
  delay(1000);
  digital_9();//9
  delay(1000);
  } 
}

{{ :rpistarterkit:p12_03.png |}} Mentsük el a fájlt, majd GCC parancs segítségével tegyük futtathatóvá. * **sudo gcc hetszegmenses.c -o hetszegmenses -lwiringPi** {{ :rpistarterkit:p12_04.png |}} Majd futtassuk le a programot, amennyiben mindent tökéletesen kötöttünk az összeszerelés közben elindul egy számláló, a kijelzőn. {{ :rpistarterkit:p12_05.png |}} {{ :rpistarterkit:p12_06.jpg |}} ---- =====13. Projekt, 74HC595 IC Modul===== **Bevezetés** Az előző projektben a Raspberry GPIO portjaival működtetünk egy 7 szegmenses kijelzőt, ám ez 8 kimenetet lefoglal a Raspberry portjaiból. Erre könnyítésül egy 74HC595 IC modult lehet segítségül hívni, amivel már csak 3 GPIO-t kell használni, bár a vezetékezés kissé nehezebb. Az IC lábkiosztása a következő. {{ :rpistarterkit:p13_02.jpg |}} **Eszközszükséglet** * 1 db 74HC595 * 1db 7 szegmenses kijelző * 8 db Ellenállás **Eszközök csatlakoztatása** A képre kattintva megtekinthető nagyobb méretben. {{ :rpistarterkit:p13_01.png |}} **Programozás** Elsőként hozzunk létre egy új C kiterjesztésű fájlt **ic.c** néven * **sudo nano ic.c** {{ :rpistarterkit:p13_03.png |}} Ezután írjuk bele a következő kódot a fájlba.

#include <wiringPi.h>
#include <wiringShift.h>
int dataPin = 23; //define three pins
int latchPin = 24;
int clockPin = 25;
int a[10]={
    252,96,218,242,102,182,190,224,254,246}; 
int x;
int main()
{
  wiringPiSetup();
 
  {
  pinMode(latchPin,OUTPUT);
  pinMode(clockPin,OUTPUT);
  pinMode(dataPin,OUTPUT); //three pins as output
  }
  
  while(1)
  { 
  for(x=0; x<10 ;x++ )        //calculate counting function
  {
    digitalWrite(latchPin,LOW);
    shiftOut(dataPin,clockPin,MSBFIRST,a[x]);     //display array a[x]
    digitalWrite(latchPin,HIGH);
    delay(1000);
  }
  }	
}

{{ :rpistarterkit:p13_04.png |}} Mentsük el majd tegyük futtathatóvá a fájlt a GCC parancs segítségével. * **sudo gcc ic.c -o ic -lwiringPi** {{ :rpistarterkit:p13_05.png |}} Végül futtassuk a programot. Ha mindent jól csináltunk, egy számláló kezd el pörögni a kijelzőnkön amit az IC vezérel. * **sudo ./ic** {{ :rpistarterkit:p13_06.png |}} ---- =====14. Projekt, 4 db 7 szegmenses kijelző===== **Bevezetés** Az előzőekben már használtunk 1 db 7 szegmenses kijelzőt. Ezúttal ugyan ezen az elven fogunk vezérelni 4 db kijelzőt. Kétféle csatlakoztatás létezik az egyik közös katódot használ, ezzel kevesebb ellenállást kell használni, de különböző fényerősséggel jelenik meg. Másik amikor mind a 8 érintkezőhöz csatlakoztatunk egy lábat, ez stabilabb, de több ellenállást használ. **Eszközszükséglet** * 4 db 7 szegmenses kijelző * 8 db Ellenállás **Eszközök csatlakoztatása** A képre kattintva megtekinthető nagyobb méretben. {{ :rpistarterkit:p14_01.png |}} **Programozás** Elsőként hozzunk létre egy fájlt **negyhetszegmens.c** néven. * **sudo nano negyhetszegmens.c** {{ :rpistarterkit:p14_02.png |}} Írjuk bele a következő kódot.

#include <wiringPi.h>
int a = 28;// GPIO20
int b = 5; // GPIO24
int c = 22;// GPIO6
int d = 24;// GPIO19
int e = 25;// GPIO26
int f = 27;// GPIO16
int g = 21;// GPIO5
int dp = 23;// GPIO13

int d4 = 3;// GPIO22
int d3 = 6;// GPIO25
int d2 = 26;// GPIO12
int d1 = 29;// GPIO21
// set variable
long n = 1230;
int x = 100;
int del = 55;    // fine adjustment for clock
void WeiXuan(unsigned char n)//
{
  switch (n)
  {
    case 1:
      digitalWrite(d1, LOW);
      digitalWrite(d2, HIGH);
      digitalWrite(d3, HIGH);
      digitalWrite(d4, HIGH);
      break;
    case 2:
      digitalWrite(d1, HIGH);
      digitalWrite(d2, LOW);
      digitalWrite(d3, HIGH);
      digitalWrite(d4, HIGH);
      break;
    case 3:
      digitalWrite(d1, HIGH);
      digitalWrite(d2, HIGH);
      digitalWrite(d3, LOW);
      digitalWrite(d4, HIGH);
      break;
    case 4:
      digitalWrite(d1, HIGH);
      digitalWrite(d2, HIGH);
      digitalWrite(d3, HIGH);
      digitalWrite(d4, LOW);
      break;
    default :
      digitalWrite(d1, HIGH);
      digitalWrite(d2, HIGH);
      digitalWrite(d3, HIGH);
      digitalWrite(d4, HIGH);
      break;
  }
}
void Num_0()
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, LOW);
  digitalWrite(dp, LOW);
}
void Num_1()
{
  digitalWrite(a, LOW);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
  digitalWrite(dp, LOW);
}
void Num_2()
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, LOW);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, LOW);
  digitalWrite(g, HIGH);
  digitalWrite(dp, LOW);
}
void Num_3()
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, HIGH);
  digitalWrite(dp, LOW);
}
void Num_4()
{
  digitalWrite(a, LOW);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(dp, LOW);
}
void Num_5()
{
  digitalWrite(a, HIGH);
  digitalWrite(b, LOW);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(dp, LOW);
}
void Num_6()
{
  digitalWrite(a, HIGH);
  digitalWrite(b, LOW);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(dp, LOW);
}
void Num_7()
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
  digitalWrite(dp, LOW);
}
void Num_8()
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(dp, LOW);
}
void Num_9()
{
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(dp, LOW);
}
void Clear()    // clear the screen
{
  digitalWrite(a, LOW);
  digitalWrite(b, LOW);
  digitalWrite(c, LOW);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
  digitalWrite(dp, LOW);
}

void pickNumber(unsigned char n)// select number
{
  switch (n)
  {
    case 0: Num_0();

      break;
    case 1: Num_1();
      break;
    case 2: Num_2();
      break;
    case 3: Num_3();
      break;
    case 4: Num_4();
      break;
    case 5: Num_5();
      break;
    case 6: Num_6();
      break;
    case 7: Num_7();
      break;
    case 8: Num_8();
      break;
    case 9: Num_9();
      break;
    default: Clear();
      break;
  }
}
void Display(unsigned char x, unsigned char Number)//    take x as coordinate and display number
{
  WeiXuan(x);
  pickNumber(Number);
  delay(1);
  Clear() ; // clear the screen
} 
int i;
int main()
{
 wiringPiSetup();
{
{
pinMode(3,OUTPUT); 
pinMode(5,OUTPUT);
pinMode(6,OUTPUT); 
} 
for(i=21;i<=29;i++)
{
pinMode(i,OUTPUT);  
} 
}
 while(1)
  { 
  int w=0;
  int s=0;
  int y=0;
  int z=0;
  unsigned long currentMillis = millis();

  while(z>=0)
  {
    while(millis()-currentMillis<100)
     {
      Display(1,w);
      Display(2,s);
      Display(3,y);
      Display(4,z);
     }
    currentMillis = millis(); 
    z++;  
  if (z>9) 
  {
   y++;
   z=0;
  }
    if (y>9) 
  {
   s++;
   y=0;
  }
    if (s>9) 
  {
   w++;
   s=0;
  }
    if (w>9) 
  {
   w=0;
   s=0;
   y=0;
   z=0;
  }
  }  
 }      
}

{{ :rpistarterkit:p14_03.png |}} Mentsük el a fájlt, majd GCC paranccsal tegyük futtathatóvá. * **sudo gcc negyhetszegmens.c -o negyhetszegmens -lwiringPi** {{ :rpistarterkit:p14_04.png |}} Végül futtassuk a fájlunkat, ha mindent jól csináltunk elindul a számláló. {{ :rpistarterkit:p14_05.png |}} {{ :rpistarterkit:p14_06.jpg |}} ---- =====15. Projekt, LED mátrix kijelző===== **Bevezetés** Ebben a projektben egy 8*8-as LED-es mátrix kijelzőt fogunk működtetni. A Raspberry 16 portját fogjuk használni, 8 fent 8 lent, így minden egyes sort és oszlopot és minden cellát képesek leszünk külön-külön villogtatni. **Eszközszükséglet** * 1 db 8*8-as LED mátrix kijelző * 8 db Ellenállás **Eszközök csatlakoztatása** A képre kattintva nagyobb méretben is megtekinthető. {{ :rpistarterkit:p15_01.png |}} **Programozás** Első lépésként hozzunk létre egy új fájlt **ledmatrix.c** néven * **sudo nano ledmatrix.c** {{ :rpistarterkit:p15_02.png |}} Ezután írjuk bele a következő kódot.


#include <wiringPi.h>
int main()
{
  wiringPiSetup();
  char i;
  char j;
  for(i=0;i<8;i++)
  {
    pinMode(i,OUTPUT);
  }
    for(j=21;j<29;j++)
  {
    pinMode(j,OUTPUT);
  }
  while(1)
  {  
    for(i=0;i<8;i++)
  {
     digitalWrite(i, HIGH);// set I/O pins as “high”
      delay(200);       // delay
  }
     for(j=21;j<29;j++)
  {
     digitalWrite(j, LOW);// set I/O pins as “low”
  }
    for(i=0;i<8;i++)
  {
     digitalWrite(i, LOW);// set I/O pins as “high”
     delay(200);       // delay
  }
    for(i=0;i<8;i++)
  {
     digitalWrite(i, HIGH);// set I/O pins as “high”
     delay(200);       // delay
  }
     for(j=21;j<29;j++)
  {
     digitalWrite(j,HIGH);// set I/O pins as “high”
     delay(200);       // delay
  }
     for(j=21;j<29;j++)
  {
     digitalWrite(j, LOW);// set I/O pins as “low”
     delay(200);       // delay
  }
    for(i=0;i<8;i++)
  {
     digitalWrite(i, LOW);// set I/O pins as “low”
     delay(200);       // delay
  }
  }    
}

{{ :rpistarterkit:p15_03.png |}}

Mentsük el, majd tegyük futtathatóvá a GCC paranccsal. * **sudo gcc ledmatrix.c -o ledmatrix -lwiringPi** {{ :rpistarterkit:p15_04.png |}} Végül futtassuk a programot, ha mindent jól kötöttünk össze, akkor a kijelzőnkön a LED-ek elkezdenek világítani. * **sudo ./ledmatrix** {{ :rpistarterkit:p15_05.png |}} ---- =====16. Projekt, 1602 LCD Kijelző===== **Bevezetés** Ebben a projektben egy 1602-es LCD kijelzőt fogunk használni, arra, hogy nullákat jelenítsünk meg rajt. **Eszközszükséglet** * 1 db 1602 LCD kijelző * 1 db Potenciométer **Eszközök csatlakoztatása** A képre kattintva nagyobb méretben is megtekinthető. {{ :rpistarterkit:p16_01.png |}} **Programozás** Először hozzunk létre egy új fájlt **LCD.c** néven. * **sudo nano LCD.c** {{ :rpistarterkit:p16_02.png |}} Ezután írjuk bele a következő C nyelvű kódot.


#include <wiringPi.h>
int main()
{

//int RS=21,RW=22,EN=23;
//int DB0=3,DB1=4,DB2=5,DB3=6,DB4=7,DB5=8,DB6=9,DB7=10;
int DB0=0,DB1=1,DB2=2,DB3=3,DB4=4,DB5=5,DB6=6,DB7=7;
int RS=21,RW=22,EN=23;
//int i;
int i;

wiringPiSetup();


   
  //Serial.begin(9600);
      pinMode(RS,OUTPUT);
      pinMode(RW,OUTPUT);
      pinMode(EN,OUTPUT);
      pinMode(DB0,OUTPUT);
      pinMode(DB1,OUTPUT);
      pinMode(DB2,OUTPUT);
      pinMode(DB3,OUTPUT);
      pinMode(DB4,OUTPUT);
      pinMode(DB5,OUTPUT);
      pinMode(DB6,OUTPUT);
      pinMode(DB7,OUTPUT);       
     
  
  digitalWrite(RS,HIGH);
  digitalWrite(RW,LOW);
  digitalWrite(RS,LOW);
  digitalWrite(EN,LOW);
  delay(1);
   //digitalWrite(DB0,0);
   //digitalWrite(DB1,0);
   digitalWrite(DB2,0);
   digitalWrite(DB3,1);
   digitalWrite(DB4,1);
   digitalWrite(DB5,1);
   digitalWrite(DB6,0);
   digitalWrite(DB7,0);
  digitalWrite(EN,HIGH);
  
  //Serial.println("zzl");
   
   delay(1);
   digitalWrite(EN,LOW);
   digitalWrite(RS,HIGH);
   
   delay(5);
  /************************************/
  digitalWrite(RS,HIGH);
  digitalWrite(RW,LOW);
  digitalWrite(RS,LOW);
  digitalWrite(EN,LOW);
  delay(1);
   digitalWrite(DB0,LOW);
   digitalWrite(DB1,LOW);
   digitalWrite(DB2,HIGH);
   digitalWrite(DB3,HIGH);
   for(i=4;i<8;i++)
   { digitalWrite(i,LOW); }  
  digitalWrite(EN,HIGH);
  

   
   delay(1);
   digitalWrite(EN,LOW);
   digitalWrite(RS,HIGH);
   
   delay(5);
  
  
  
  /**************************************/
  digitalWrite(RS,HIGH);
  digitalWrite(RW,LOW);
  digitalWrite(RS,LOW);
  digitalWrite(EN,LOW);
  delay(1);
   digitalWrite(DB0,LOW);
   digitalWrite(DB1,HIGH);
   digitalWrite(DB2,HIGH);
   digitalWrite(DB3,LOW);
   for(i=4;i<8;i++)
   { digitalWrite(i,LOW); }  
  digitalWrite(EN,HIGH);
  

   
   delay(1);
   digitalWrite(EN,LOW);
   digitalWrite(RS,HIGH);
   
   delay(5);
   /*******************************************/
   
  digitalWrite(RS,HIGH);
  digitalWrite(RW,LOW);
  digitalWrite(RS,LOW);
  digitalWrite(EN,LOW);
  delay(1);
   digitalWrite(DB0,HIGH);
   for(i=1;i<8;i++)
   { digitalWrite(i,LOW); }  
   digitalWrite(EN,HIGH);
    
   delay(1);
   digitalWrite(EN,LOW);
   digitalWrite(RS,HIGH);
   
   delay(5);
   /*************************************************/
 // put your setup code here, to run once:

for (;;) 
{
  digitalWrite(RS,LOW);
  digitalWrite(RW,LOW);
  digitalWrite(RS,HIGH);
  digitalWrite(EN,LOW);
  delay(1);
     for(i=0;i<4;i++)
    {digitalWrite(i,LOW);}
    digitalWrite(DB4,HIGH);
    digitalWrite(DB5,HIGH);
    digitalWrite(DB6,LOW);
    digitalWrite(DB7,LOW);
  digitalWrite(EN,HIGH);
  

  
   
   delay(1);
   digitalWrite(EN,LOW);
   digitalWrite(RS,LOW);
   delay(100);
   //while(1);
   //delay(5000);
  // put your main code here, to run repeatedly:

}
return 0;
}

{{ :rpistarterkit:p16_03.png |}} Mentsük el, majd tegyük futtathatóvá a GCC parancs segítségével. * **sudo gcc LCD.c -o LCD -lwiringPi** {{ :rpistarterkit:p16_04.png |}} Végül futtassuk a programot, ha megfelelően kötöttünk mindent, a kijelzőn nulláknak kell megjelennie. * **sudo ./LCD** {{ :rpistarterkit:p16_05.png |}} ---- =====17. Projekt, RGB LED===== **Bevezetés** A Raspberryvel képesek vagyunk egy RGB LED vezérlésére, a három alapszín és azok keverékeinek előállítására. **Eszközszükséglet** * 1 db RGB LED * 3 db Ellenállás **Eszközök csatlakoztatása** A képre kattintva nagyobb méretben is megtekinthető. {{ :rpistarterkit:p17_01.png |}} **Programozás** Először is hozzunk létre egy új fájlt **rgb.c** néven. * **sudo nano rgb.c** {{ :rpistarterkit:p17_02.png |}} Ezután írjuk bele a fájlba a következő kódot.


#include <wiringPi.h>
#include <softPwm.h>
#include <stdio.h>
  
#define LedPinRed    0  
#define LedPinGreen  1  
#define LedPinBlue   2  
  
int colors[] = {0xFF0000, 0x00FF00, 0x0000FF, 0xFFFF00, 0x00FFFF, 0xFF00FF, 0xFFFFFF, 0x9400D3};  
  
/****************************************************************************************** 
*A number is linear mapped from a range to another one, for example, a number from 0 to 100 is mapped to 0 ~ 255. 
******************************************************************************************/  
int map(int x, int in_min, int in_max, int out_min, int out_max)     
{  
    return (x -in_min) * (out_max - out_min) / (in_max - in_min) + out_min;  
}  
  
void ledInit(void)  
{  
    softPwmCreate(LedPinRed,  0, 100);  //create a soft pwm, original duty cycle is 0Hz, range is 0~100   
    softPwmCreate(LedPinGreen,0, 100);  
    softPwmCreate(LedPinBlue, 0, 100);  
}  
  
void ledColorSet(int color)        //set color, for example: 0xde3f47  
{  
    int r_val, g_val, b_val;  
  
    r_val = (color & 0xFF0000) >> 16;  //get red value  
    g_val = (color & 0x00FF00) >> 8;   //get green value  
    b_val = (color & 0x0000FF) >> 0;   //get blue value  
  
    r_val = map(r_val, 0, 255, 0, 100);   //change a num(0~255) to 0~100  
    g_val = map(g_val, 0, 255, 0, 100);  
    b_val = map(b_val, 0, 255, 0, 100);  
      
    softPwmWrite(LedPinRed,   100 - r_val);  //change duty cycle  
    softPwmWrite(LedPinGreen, 100 - g_val);  
    softPwmWrite(LedPinBlue,  100 - b_val);  
}  
  
int main(void)  
{  
    int i;  
  
    if(wiringPiSetup() == -1){      //when initialize wiringPi failed, print message to screen  
        printf("setup wiringPi failed !\n");  
        return 1;   
    }  
  
    ledInit();  
  
    while(1){  
        for(i = 0; i < sizeof(colors)/sizeof(int); i++){  
            ledColorSet(colors[i]);  
            delay(500);  
        }  
    }  
  
    return 0;  
}

{{ :rpistarterkit:p17_03.png |}} Mentsük el, majd tegyük futtathatóvá a fájlt a GCC paranccsal. * **sudo gcc rgb.c -o rgb -lwiringPi** {{ :rpistarterkit:p17_04.png |}} Végül futtassuk a programot. * **sudo ./rgb** {{ :rpistarterkit:p17_05.png |}} ---- =====18. Projekt, 9g Szervó===== **Bevezetés** A következő projektben egy szervó motort fogunk mozgatni PWM jel segítségével. Ez azt jelenti, hogy nagyon rövid milisecundumos jeleket fogunk kiadni, és ezek fogják mozgatni a megfelelő szögbe a szervót. **Eszközszükséglet** * 1 db 9g Szervó motor * Keyestudio RPI GPIO-PCF8591 kártya **Eszközök csatlakoztatása** A képre kattintva nagyobb méretben is megtekinthető. {{ :rpistarterkit:p18_01.png |}} **Programozás** Először is hozzunk létre egy új fájlt **servo.c** néven. * **sudo nano servo.c** {{ :rpistarterkit:p18_02.png |}} Ezután írjuk bele a következő kódot a fájlunkba.

#include <wiringPi.h>
int main()
{
	wiringPiSetup();
	pinMode(1,OUTPUT);
	int i;
	for(;;)
	{
		
		for(i=0;i<50;i++)            
		{
		digitalWrite(1,HIGH);
		delayMicroseconds(1000);
		digitalWrite(1,LOW);
      delay(19);	
		}
		
		delay(1000);
		
		for(i=0;i<50;i++)         
		{
		digitalWrite(1,HIGH);
		delayMicroseconds(2000);
		digitalWrite(1,LOW);
	        delay(18);	
		}
                delay(1000);	
	}
	return 0;
}

{{ :rpistarterkit:p18_03.png |}} Ha ezzel megvagyunk, tegyük futtathatóvá a fájlunkat a GCC parancs segítségével. * **sudo gcc servo.c -o servo -lwiringPi** {{ :rpistarterkit:p18_04.png |}} Végül futtassuk a programot. * **sudo ./servo** {{ :rpistarterkit:p18_05.png |}} ---- =====19. Projekt, ULN2003 Léptető motor===== **Bevezetés** Ebben a projektben megtanuljuk, hogyan forgassunk meg egy léptetőmotort 360°-ban Raspberry Pi segítségével. **Eszközszükséglet** * 1 db Léptető motor a hozzá tartozó vezérlővel * Keyestudio RPI GPIO-PCF8591 kártya **Eszközök csatlakoztatása** A képre kattintva nagyobb méretben is megtekinthető. {{ :rpistarterkit:p19_01.png |}} **Programozás** Először hozzunk létre egy új fájlt **leptetomotor.c** néven. * **sudo nano leptetomotor.c** {{ :rpistarterkit:p19_02.png |}} Ezután írjuk a fájlba a következő kódot.

/* moto.c
* A program to control a stepper motor through the GPIO on Raspberry Pi. 
* Author: Darran Zhang (http://www.codelast.com) 
*/ 
#include <wiringPi.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
 
#define CLOCKWISE 1
#define COUNTER_CLOCKWISE 2
void delayMS(int x);
void rotate(int* pins, int direction);
int main(int argc,char* argv[]) {
  if (argc < 4) {
    printf("Igy hasznald kerlek: ./leptetomotor 0 1 2 3 \n");
    return 1;
  }
 
  /* number of the pins which connected to the stepper motor driver board */
  int pinA = atoi(argv[1]);
  int pinB = atoi(argv[2]);
  int pinC = atoi(argv[3]);
  int pinD = atoi(argv[4]);
 
  int pins[4] = {pinA, pinB, pinC, pinD};
 
  if (-1 == wiringPiSetup()) {
    printf("Setup wiringPi failed!");
    return 1;
  }
 
  /* set mode to output */
  pinMode(pinA, OUTPUT);
  pinMode(pinB, OUTPUT);
  pinMode(pinC, OUTPUT);
  pinMode(pinD, OUTPUT);
 
  delayMS(50);    // wait for a stable status 
  for (int i = 0; i < 500; i++) {
    rotate(pins, CLOCKWISE);
  }
 
  return 0;
}
 
/* Suspend execution for x milliseconds intervals.
 *  @param ms Milliseconds to sleep.
 */
void delayMS(int x) {
  usleep(x * 1000);
}
 
/* Rotate the motor.
 *  @param pins     A pointer which points to the pins number array.
 *  @param direction  CLOCKWISE for clockwise rotation, COUNTER_CLOCKWISE for counter clockwise rotation.
 */
void rotate(int* pins, int direction) {
  for (int i = 0; i < 4; i++) {
    if (CLOCKWISE == direction) {
      for (int j = 0; j < 4; j++) {
        if (j == i) {
          digitalWrite(pins[3 - j], 1); // output a high level 
        } else {
          digitalWrite(pins[3 - j], 0); // output a low level 
        }
      }
    } else if (COUNTER_CLOCKWISE == direction) {
      for (int j = 0; j < 4; j++) {
        if (j == i) {
          digitalWrite(pins[j], 1); // output a high level 
        } else {
          digitalWrite(pins[j], 0); // output a low level 
        }
      }
    }
    delayMS(4);
  }
}

{{ :rpistarterkit:p19_03.png |}} Mentsük el a fájlt, majd tegyük futtathatóvá a már jól ismert GCC parancs segítségével. * **sudo gcc leptetomotor.c -o leptetomotor -lwiringPi** {{ :rpistarterkit:p19_04.png |}} Végül futtassuk a programot, és adjuk meg neki, hogy egy teljes kört menjen, az alábbi módon. * **sudo ./leptetomotor 0 1 2 3** {{ :rpistarterkit:p19_05.png |}} ---- =====20. Projekt, Photo ellenállás===== **Bevezetés** Ebben a projektben egy photo ellenállással fogjuk mérni a fény erősségét, és ennek függvényében vezéreljük egy LED fényét. **Eszközszükséglet** * 1 db Photo ellenállás * 1 db Piros LED * 2 db Ellenállás **Eszközök csatlakoztatása** A képre kattintva nagyobb méretben is megtekinthető. {{ :rpistarterkit:p20_01.png |}} **Programozás** Először is be kell kapcsolnunk az I2C vezérlő egységet a Raspberry beállításaiban. * **sudo rapsi-config** {{ :rpistarterkit:p20_02.png |}} Itt menjünk az **Interfacing Options**-ba. {{ :rpistarterkit:p20_03.png |}} Itt válasszuk ki az **I2C** pontot, és kapcsoljuk be. {{ :rpistarterkit:p20_04.png |}} Majd nyomjuk meg kétszer a jobbra nyilat és válasszuk a **Finish**-t és lépjünk ki. {{ :rpistarterkit:p20_05.png |}} ---- Amint ezekkel kész vagyunk jöhet a programozás. Hozzunk létre egy új fájlt **photoellenallas.c** néven. * **sudo nano photoellenallas.c** {{ :rpistarterkit:p20_06.png |}} Majd írjuk bele a következő kódot.

{{ :rpistarterkit:p20_07.png |}} Mentsük el, majd tegyük futtathatóvá a fájlt a GCC parancs segítségével. * **sudo gcc photoellenallas.c -o photoellenallas -lwriringPi** {{ :rpistarterkit:p20_08.png |}} Végül futtassuk a fájlt és nézzük meg az eredményt. Amit kiír az az A0 tehát Analóg porton olvasott értékek, ami a beeső fény erősségét mutatja, minél több, annál jobban fog világítani a LED. {{ :rpistarterkit:p20_09.png |}} ---- =====21. Projekt, LM35 Hőmérséklet érzékelő===== **Bevezetés** Ebben a részben, egy hőmérséklet érzékelő szenzort fogunk vizsgálni. **Eszközszükséglet** * 1 db LM35 Hőmérséklet érzékelő **Eszközök csatlakoztatása** A képre kattintva nagyobb méretben is megtekinthető. {{ :rpistarterkit:p21_01.png |}} **Programozás** Elsőként ha még nem tettük meg, kapcsoljuk be az I2C modult. Erre leírást a 20-as projektben talál. Ha ezt megcsinálta, hozzon létre egy új fájlt **homero.c** néven. * **sudo nano homero.c** {{ :rpistarterkit:p21_02.png |}} Ezután írjuk bele a következő kódot.


#include <wiringPi.h>
#include <pcf8591.h>
#include <stdio.h>

#define Address 0x48
#define BASE 64
#define A0 BASE+0
#define A1 BASE+1
#define A2 BASE+2
#define A3 BASE+3

int main(void)
{
        unsigned char value;
	wiringPiSetup();
	pcf8591Setup(BASE,Address);
	
	while(1)
	{
               value=analogRead(A0); 
               value=(500 * value) /256;             
               printf("Temp:%d C\n",value);
               delay(50);
			
	}
}

{{ :rpistarterkit:p21_03.png |}} Mentsük el, majd tegyük futtathatóvá a fájlt a GCC paranccsal. * **sudo gcc homero.c -o homero -lwiringPi** {{ :rpistarterkit:p21_04.png |}} Végül futtassuk a programot, ha mindent jól kötöttünk, akkor a képernyőn megjelenik a mért hőmérséklet. * **sudo ./homero** {{ :rpistarterkit:p21_05.png |}} ---- =====22. Projekt, PCF8591 Potméter===== **Bevezetés** A Raspberry Pi alapvetően nem rendelkezik AD / DA (A : Analóg, D : Digitális) átalakító funkcióval, ezért ha analóg jelet akarunk érzékelni csatlakoztatni kell hozzá a Keyestudio RPI GPIO-PCF8591 kártyát. Ezután be kell kapcsolni az I2C interfészt, hogy tudjuk használni az analóg csatlakozót. **Eszközszükséglet** * 1 db Potenciométer * Keyestudio RPI GPIO-PCF8591 kártya **Eszközök csatlakoztatása** A képre kattintva nagyobb méretben is megtekinthető. {{ :rpistarterkit:p22_01.png |}} **Programozás** Először kapcsoljuk be az I2C modult, ha még nem lenne bekapcsolva. Ennek részletes leírását a 20-as projektben találja. Ha bekapcsoltuk, akkor hozzunk létre egy új fájlt **potmeter.c** néven. * **sudo nano potmeter.c** {{ :rpistarterkit:p22_02.png |}} Írjuk a fájlba a következő kódot.


#include <wiringPi.h>
#include <pcf8591.h>
#include <stdio.h>

#define Address 0x48         //pcf8591 Address
#define BASE 64
#define A0 BASE+0           //input address of A0
#define A1 BASE+1           //input address of A1
#define A2 BASE+2           //input address of A2
#define A3 BASE+3           //input address of A3
int main(void)
{
    unsigned char value;
	wiringPiSetup();
	pcf8591Setup(BASE,Address);        //configure pcf8591
	
	while(1)
	{
               value=analogRead(A0);     // read the value of A0 port         
               printf("A0:%d\n",value);  // print the value of A0 on the terminal
               delay(100);	
	}
}

{{ :rpistarterkit:p22_03.png |}} Mentsük el, majd tegyük futtathatóvá a Raspberry számára a GCC paranccsal. * **sudo gcc potmeter.c -o potmeter -lwiringPi** {{ :rpistarterkit:p22_04.png |}} Végül futtassuk a programot, ha jól csináltuk a potmétert tekergetve különböző értékeket kapunk majd. * **sudo ./potmeter** {{ :rpistarterkit:p22_05.png |}} ---- =====23. Projekt, PIR Mozgásérzékelő szenzor===== **Bevezetés** Ebben a projektben egy PIR mozgásérzékelőt fogunk használni, annak érdekében, hogy megállapítsuk van-e valaki a helységben vagy sem. Ha mozgást észlel kiírja "Somebody is in this area!" ha nemNo one!". **Eszközszükséglet** * 1 db PIR mozgásérzékelő * 1 db Piros LED * 1 db Ellenállás * Keyestudio RPI GPIO-PCF8591 kártya **Eszközök csatlakoztatása** A képre kattintva megtekinthető nagyobb méretben is. {{ :rpistarterkit:p23_01.png |}} **Programozás** Először hozzunk létre egy új fájlt **mozgaserzekelo.c** néven. * **sudo nano mozgaserzekelo.c** {{ :rpistarterkit:p23_02.png |}} Ebbe a fájlba írjuk bele a következő kódot.


#include <wiringPi.h>
#include <stdio.h>

int main()
{
  wiringPiSetup();
  char val;
  {
    pinMode(1,INPUT);
    pinMode(2,OUTPUT);
  }
  
  while(1)
  { 
   val=digitalRead(1);
   if(val==1)
  {
   printf("Somebody is in this area!\n");
   digitalWrite(2,HIGH);
   delay(100);
  }

   else
  {
   printf("No one!\n");
   digitalWrite(2,LOW);
   delay(100);
  }
  }	
}

{{ :rpistarterkit:p23_03.png |}} Mentsük el, majd tegyük futtathatóvá a GCC paranccsal. * **sudo gcc mozgaserzekelo.c -o mozgaserzekelo -lwiringPi** {{ :rpistarterkit:p23_04.png |}} Végül futtassuk a fájlt, a megszokott módon. * **sudo ./mozgaserzekelo** {{ :rpistarterkit:p23_05.png |}} ---- =====24. Projekt, MQ-2 Analóg Gáz érzékelő===== **Bevezetés** Ebben a projektben egy analóg ház szenzort fogunk tesztelni. Megmérjük, hogy tartalmaz-e nagy mennyiségben a levegő, propán, hidrogén, vagy egyéb gázokat. **Eszközszükséglet** * 1 db Analóg gáz érzékelő * Keyestudio RPI GPIO-PCF8591 kártya **Eszközök csatlakoztatása** A képre kattintva nagyobb méretben is megtekinthető. {{ :rpistarterkit:p24_01.png |}} **Programozás** Először is be kell kapcsolni az I2C modult, amennyiben még nincs bekapcsolva, vagy nem tudja hogyan kellene, menjen vissza a 20. Projekthez és ott megtalálja a bekapcsoláshoz szükséges lépéseket. Bekapcsolás után hozzunk létre egy új fájlt **gazerzekelo.c** néven. * **sudo nano gazerzekelo.c** {{ :rpistarterkit:p24_02.png |}} Ezután írjuk bele a következő kódot.


#include <wiringPi.h>
#include <pcf8591.h>
#include <stdio.h>

#define Address 0x48
#define BASE 64
#define A0 BASE+0
#define A1 BASE+1
#define A2 BASE+2
#define A3 BASE+3

int main(void)
{
      unsigned char value;
	wiringPiSetup();
      pinMode(1,OUTPUT);
	pcf8591Setup(BASE,Address);
        
	while(1)
	{
        value=analogRead(A0);              
        printf("A0:%d\n",value);
        delay(100);
	}
     }

{{ :rpistarterkit:p24_03.png |}} Mentsük el, majd tegyük futtathatóvá a fájlt a Raspberry számára a GCC paranccsal. * **sudo gcc gazerzekelo.c -o gazerzekelo -lwiringPi** {{ :rpistarterkit:p24_04.png |}} Végül futtassuk a fájlt és nézzük meg a végeredményt. * **sudo ./gazerzekelo** {{ :rpistarterkit:p24_05.png |}} ---- =====25. Projekt, ADXL345 Gyorsulás mérő ===== **Bevezetés** Ebben a projektben, egy három tengelyes gyorsulás mérőt csatlakoztatunk a Raspberryhez, amivel képesek vagyunk mérni a legkisebb elmozdulást is. **Eszközszükséglet** * 1 db ADXL345 gyorsulás mérő * Keyestudio RPI GPIO-PCF8591 kártya **Eszközök csatlakoztatása** A képre kattintva megtekinthető nagyobb méretben is. {{ :rpistarterkit:p25_01.png |}} **Programozás** Először is be kell kapcsolnunk az I2C modult, amennyiben még nincs bekapcsolva, vagy nem tudja hogyan kell, menjen vissza a 20. Projekthez ahol részletesen elmagyarázzuk, hogy is kell csinálni. Ezután hozzunk létre egy új fájlt **gyorsulas.c** néven. * **sudo nano gyorsulas.c** {{ :rpistarterkit:p25_02.png |}} Ezután írjuk a következő kódot a fájlba.

#include <wiringPiI2C.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

#define  DevAddr  0x53  //device address

struct acc_dat{
	int x;
	int y;
	int z;
};

void adxl345_init(int fd)
{
	wiringPiI2CWriteReg8(fd, 0x31, 0x0b);
	wiringPiI2CWriteReg8(fd, 0x2d, 0x08);
//	wiringPiI2CWriteReg8(fd, 0x2e, 0x00);
	wiringPiI2CWriteReg8(fd, 0x1e, 0x00);
	wiringPiI2CWriteReg8(fd, 0x1f, 0x00);
	wiringPiI2CWriteReg8(fd, 0x20, 0x00);
	
	wiringPiI2CWriteReg8(fd, 0x21, 0x00);
	wiringPiI2CWriteReg8(fd, 0x22, 0x00);
	wiringPiI2CWriteReg8(fd, 0x23, 0x00);

	wiringPiI2CWriteReg8(fd, 0x24, 0x01);
	wiringPiI2CWriteReg8(fd, 0x25, 0x0f);
	wiringPiI2CWriteReg8(fd, 0x26, 0x2b);
	wiringPiI2CWriteReg8(fd, 0x27, 0x00);
	
	wiringPiI2CWriteReg8(fd, 0x28, 0x09);
	wiringPiI2CWriteReg8(fd, 0x29, 0xff);
	wiringPiI2CWriteReg8(fd, 0x2a, 0x80);
	wiringPiI2CWriteReg8(fd, 0x2c, 0x0a);
	wiringPiI2CWriteReg8(fd, 0x2f, 0x00);
	wiringPiI2CWriteReg8(fd, 0x38, 0x9f);
}

struct acc_dat adxl345_read_xyz(int fd)
{
	char x0, y0, z0, x1, y1, z1;
	struct acc_dat acc_xyz;

	x0 = 0xff - wiringPiI2CReadReg8(fd, 0x32);
	x1 = 0xff - wiringPiI2CReadReg8(fd, 0x33);
	y0 = 0xff - wiringPiI2CReadReg8(fd, 0x34);
	y1 = 0xff - wiringPiI2CReadReg8(fd, 0x35);
	z0 = 0xff - wiringPiI2CReadReg8(fd, 0x36);
	z1 = 0xff - wiringPiI2CReadReg8(fd, 0x37);

	acc_xyz.x = (int)(x1 << 8) + (int)x0;
	acc_xyz.y = (int)(y1 << 8) + (int)y0;
	acc_xyz.z = (int)(z1 << 8) + (int)z0;

	return acc_xyz;
}

int main(void)
{
	int fd;
	struct acc_dat acc_xyz;

	fd = wiringPiI2CSetup(DevAddr);
	
	if(-1 == fd){
		perror("I2C device setup error");	
	}

	adxl345_init(fd);

	while(1){
		acc_xyz = adxl345_read_xyz(fd);
		printf("x: %05d  y: %05d  z: %05d\n", acc_xyz.x, acc_xyz.y, acc_xyz.z);

	}
	
	return 0;
}

{{ :rpistarterkit:p25_03.png |}} Mentsük el, majd tegyük futtathatóvá a fájlt a GCC parancs segítségével. * **sudo gcc gyorsulas.c -o gyorsulas -lwiringPi** {{ :rpistarterkit:p25_04.png |}} Végül futtassuk a programot, ha mindent jól csináltunk, akkor ha mozgatjuk az eszközt akkor megkapjuk az elmozdulás mértékét. * **sudo ./gyorsulas** {{ :rpistarterkit:p25_05.png |}} ---- =====26. Projekt, Ultrahangos érzékelő ===== **Bevezetés** Ebben a projektben egy ultrahangos érzékelővel fogjuk mérni, hogy az adott tárgy milyen messze van tőlünk adott távolságon belül. **Eszközszükséglet** * 1 db Ultrahangos érzékelő * Keyestudio RPI GPIO-PCF8591 kártya **Eszközök csatlakoztatása** A képre kattintva megtekinthető nagyobb méretben is. {{ :rpistarterkit:p26_01.png |}} **Programozás** Hozzunk létre egy új fájlt **ultrahang.c** néven. * **sudo nano ultrahang.c** {{ :rpistarterkit:p26_02.png |}} Ezután írjuk bele a következő C nyelvű kódot.


#include <wiringPi.h>
#include <stdio.h>
#include <sys/time.h>

#define Trig    5
#define Echo   4
void ultraInit(void)
{
	pinMode(Echo, INPUT);
	pinMode(Trig, OUTPUT);
}

float disMeasure(void)
{
	struct timeval tv1;
	struct timeval tv2;
	long start, stop;
	float dis;

	digitalWrite(Trig, LOW);
	delayMicroseconds(2);

	digitalWrite(Trig, HIGH);
	delayMicroseconds(10);      	
    digitalWrite(Trig, LOW);
	
	while(!(digitalRead(Echo) == 1));
	gettimeofday(&tv1, NULL);           

	while(!(digitalRead(Echo) == 0));
	gettimeofday(&tv2, NULL);           

	start = tv1.tv_sec * 1000000 + tv1.tv_usec;   
	stop  = tv2.tv_sec * 1000000 + tv2.tv_usec;

	dis = (float)(stop - start) / 1000000 * 34000 / 2;  

	return dis;
}

int main(void)
{
	float dis;

	if(wiringPiSetup() == -1){ //when initialize wiring failed,print messageto screen
		printf("setup wiringPi failed !");
		return 1; 
	}

	ultraInit();
	
	while(1){
		dis = disMeasure();
		printf("distance = %0.2f cm\n",dis);
		delay(500);
	}

	return 0;
}

{{ :rpistarterkit:p26_03.png |}} Mentsük el, majd tegyük futtathatóvá a GCC parancs segítségével. * **sudo gcc ultrahang.c -o ultrahang -lwiringPi** {{ :rpistarterkit:p26_04.png |}} Futtassuk a fájlt, ha mindent jól csináltunk akkor közel pontosan megkapjuk, hogy az adott tárgy milyen távolságra van a szenzortól. * **sudo ./ultrahang** {{ :rpistarterkit:p26_05.png |}} ---- =====27. Projekt, Joystick modul ===== **Bevezetés** A joystick modul 2 potenciométerből áll, amit megfeleltetünk X és Y tengelynek. Z tengelynek egy gombot használunk. A joystick jeleit analóg módon tudjuk érzékelni ezért szükségünk van a Keyestudio RPI GPIO... kártyájára, mivel a Raspberry önmagában nem rendelkezik ilyen ki/bemenettel. **Eszközszükséglet** * 1 db Joystick modul * Keyestudio RPI GPIO-PCF8591 kártya **Eszközök csatlakoztatása** A képre kattintva megtekinthető nagyobb méretben is. {{ :rpistarterkit:p27_01.png |}} **Programozás** Mivel analóg modult használunk, először be kell kapcsolni az I2C modult. Amennyiben még nem tette meg vagy nem tudja hogy kell, menjen vissza a 20. Projekthez, ahol minden részletesen el van magyarázva. Ezután hozzunk létre egy új fájlt **joystick.c** néven. * **sudo nano joystick.c** {{ :rpistarterkit:p27_02.png |}} Majd írjuk bele a következő kódot.


#include <wiringPi.h>
#include <pcf8591.h>
#include <stdio.h>

#define Address 0x48
#define BASE 64
#define A0 BASE+0
#define A1 BASE+1
#define A2 BASE+2
#define A3 BASE+3
char dat;

int main(void)
{
        unsigned char value;
	wiringPiSetup();
        pinMode(1,INPUT);
	pcf8591Setup(BASE,Address);
	while(1)
	{
               value=analogRead(A0);              
               printf("X:%d    ",value);
               value=analogRead(A1);              
               printf("Y:%d    ",value);
               dat=digitalRead(1);
               if(dat==HIGH)
                  printf("DO:%d\n",dat);
               if(dat==LOW)
                  printf("DO:%d\n",dat);
               delay(100);

               // analogWrite(BASE,value++);
               // printf("AOUT:%d\n",value++);
               // delay(50);
	}
}

{{ :rpistarterkit:p27_03.png |}} Mentsük el, majd tegyük futtathatóvá a GCC parancs segítségével. * **sudo gcc joystick.c -o joystick -lwiringPi** {{ :rpistarterkit:p27_04.png |}} Majd végül futtassuk a programot, ha mindent jól csináltunk, megkapjuk X,Y és Z értéket ahol Z gombként van jelen. * **sudo ./joystick** {{ :rpistarterkit:p27_05.png |}} ---- =====28. Projekt, 5V Relay ===== **Bevezetés** Ebben a projektben, egy egyszerű 5V-os relét fogunk tesztelni. A relé attól függően kapcsol hogy magas vagy alacsony jelet kap. Ezzel a módszerrel fogunk egy LED-et villogtatni a következőkben. **Eszközszökséglet** * 1 db Relay modul * 1 db Piros LED * 1 db Ellenállás * Keyestudio PRI GPIO-PCF8591 kártya **Eszközök csatlakoztatása** A képre kattintva megtekinthető nagyobb méretben is. {{ :rpistarterkit:p28_01.png |}} **Programozás** Első lépésként, hozzunk létre egy új fájlt **relay.c** néven. * **sudo nano relay.c** {{ :rpistarterkit:p28_02.png |}} Ezután írjuk bele a következő kódot.


#include <wiringPi.h>
int main()
{
  wiringPiSetup();

  {
        pinMode(1,OUTPUT);
  }
  
  while(1)
  { 
        digitalWrite(1,HIGH);
        delay(500);
        digitalWrite(1,LOW);
        delay(500);	  
  }
	
}

{{ :rpistarterkit:p28_03.png |}} Mentsük el, majd tegyük futtathatóvá a GCC paranccsal. * **sudo gcc relay.c -o relay -lwiringPi** {{ :rpistarterkit:p28_04.png |}} Végül futtassuk, ha mindent jól csináltunk, egy kattogó hang keretében a LED fel és le fog kapcsolni. A kattogó hang ahogy a relay kapcsolja a benne lévő mechanikus kapcsolót. * **sudo ./relay** {{ :rpistarterkit:p28_05.png |}} ---- =====29. Projekt, DHT11 Hőmérséklet és Páratartalom érzékelő ===== **Bevezetés** ---- =====30. Projekt, Talaj nedvesség érzékelő ===== **Bevezetés** Ebben a projektbe, a talaj nedvesség tartalmának vizsgálására alkalmas eszközt fogunk tesztelni. **Eszközszükséglet** * 1 db Talaj nedvesség érzékelő * Keyestudio RPI GPIO-PCF8591 kártya **Eszközök csatlakoztatása** A képre kattintva nagyobb méretben is megtekinthető. {{ :rpistarterkit:p30_01.png |}} **Programozás** Első lépésként kapcsoljuk be az I2C modult, amennyiben még nincs bekapcsolva, vagy nem tudja, hogyan kell, menjen vissza a 20. Projekthez ahol részletesen elmagyarázzuk, a bekapcsolás menetét. Bekapcsolás után, hozzunk létre egy úgy fájlt **talajnedvesseg.c** néven. * **sudo nano talajnedvesseg.c** {{ :rpistarterkit:p30_02.png |}} Majd írjuk bele a következő kódot.


#include <wiringPi.h>
#include <pcf8591.h>
#include <stdio.h>

#define Address 0x48
#define BASE 64
#define A0 BASE+0
#define A1 BASE+1
#define A2 BASE+2
#define A3 BASE+3

int main(void)
{
    unsigned char value;
	wiringPiSetup();
	pcf8591Setup(BASE,Address);
	
	while(1)
	{
               value=analogRead(A0);              
               printf("S:%d\n",value);
               delay(50);			
	}
}

{{ :rpistarterkit:p30_03.png |}} Mentsük el, majd tegyük futtathatóvá GCC paranccsal. * **sudo gcc talajnedvesseg.c -o talajnedvesseg -lwiringPi** {{ :rpistarterkit:p30_04.png |}} Végül futtassuk és nézzük meg milyen értéket ad a talaj nedvességére. * **sudo ./talajnedvesseg** {{ :rpistarterkit:p30_05.png |}} ---- =====31. Projekt, DS3231 Órajel generátor modul===== ----