WIKI-VIGVÁRI

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.

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.

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.

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.

Í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.

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.

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.

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/

Ha nem kapunk semmi üzenetet azt jelenti létrehozta a mappát Majd a mappába való belépéshez

• cd starterkit/

É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

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);

 }
}

A mentés folyamata a következő:

1. Nyomjuk le a Ctrl+X kombinációt
2. Megkérdezi, hogy menti-e a módosított fájlt. Erre I/N a válasz, jelen esetben I.
3. 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

Végül nézzük meg mi lett az eredmény, futtassuk a fájlt a következő képen.

• ./hellovilag

A programot a Ctrl+C kombinációval tudjuk megszakítani.

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!

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

Í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);	  
  }
	
}

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

A fájl futtatása után, ha mindent helyesen kötöttünk be, a LED elkezd villogni.

• ./ledvillogtatas

A folyamat megszakításához nyomjuk le a Ctrl+C kombinációt.

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.

Programozás

Először is hozzunk létre egy új C fájlt amibe a programunkat írni fogjuk.

• sudo nano legzeseffekt.c

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;
 }

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

Végül futtassuk a programot sudo paranccsal. Ha mindent jól csináltunk akkor a LED lassan felgyúl majd elalszik.

• sudo ./legzeseffekt

A program megállítása a már ismert Ctrl+C gomb kombinációval lehetséges.

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.

Programozás

Először hozzunk létre egy új C fájlt kozlekedesilampa.c néven.

• sudo nano kozlekedesilampa.c

Í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
   } 
}

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

Majd futtassuk a programot sudo-ként.

• sudo ./kozlekedesilampa

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.

Programozás

Hozzunk létre egy új fájlt futofeny.c néven.

• sudo nano futofeny.c

Í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
   } 
  }    
}

Ezek után tegyük futtathatóvá a fájlunkat a már ismert GCC paranccsal.

• sudo gcc futofeny.c -o futofeny -lwiringPi

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

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.

Programozás

Először hozzunk létre egy új fájlt gombled.c néven.

• sudo nano gombled.c

Í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);
  }	
}

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

Végül pedig futtassuk a programot, ha mindent jól csináltunk a gomb megnyomására a LED felvillan.

• ./gombled

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.

Programozás

Elsőként hozzunk létre egy új fájlt passzivcsipogo.c néven.

• sudo nano passzivcsipogo.c

Í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 
     }
   } 	  
  }

Mentsük el, majd a GCC paranccsal tegyük futtathatóvá a fájlt

• sudo gcc passzivcsipogo.c -o paszivcsipogo -lwiringPi

Végül futtassuk a fájlt, amennyiben mindent jól csináltunk, a csipogó megszólal.

• sudo ./passzivcsipogo

A programot a Ctrl+C billentyűkombinációval tudjuk leállítani

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.

Programozás

Elsőként hozzunk létre egy új fájlt aktivcsipogo.c néven

• sudo nano aktivcsipogo.c

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);	  
  }
	
}

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

Végül futtassuk a programot.

• sudo ./aktivcsipogo

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ő.

Programozás

Első lépésként hozzunk létre egy új fájlt tuzerzekelo.c néven.

• sudo nano tuzerzekelo.c

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);
  }	
}

Tegyük futtathatóvá a fájlunkat a GCC parancs segítségével.

• sudo gcc tuzerzekelo.c -o tuzerzekelo -lwiringPi

Végül pedig futtassuk a programot a már ismert módon.

• sudo ./tuzerzekelo

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ő.

Programozás

Első lépésként hozzunk létre egy új fájlt golyo.c néven.

• sudo nano golyo.c

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);
  }	
}

Mentsük el, majd tegyük futtathatóvá a GCC parancs segítségével.

• sudo gcc golyo.c -o golyo -lwiringPi

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

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ő.

Programozás

Először hozzunk létre egy új fájlt taviranyito.c néven.

• sudo nano taviranyito.c

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]);
		}
	}
}

Tegyük futtathatóvá C nyelvű fájlunkat a GCC parancs segítségével.

• sudo gcc taviranyito.c -o taviranyito -lwiringPi

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

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ő.

Programozás

Elsőként hozzunk létre egy, hetszegmenses.c nevű fájlt.

• sudo nano hetszegmenses.c

Í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);
  } 
}

Mentsük el a fájlt, majd GCC parancs segítségével tegyük futtathatóvá.

• sudo gcc hetszegmenses.c -o hetszegmenses -lwiringPi

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.

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ő.

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.

Programozás

Elsőként hozzunk létre egy új C kiterjesztésű fájlt ic.c néven

• sudo nano ic.c

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);
  }
  }	
}

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

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

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.

Programozás

Elsőként hozzunk létre egy fájlt negyhetszegmens.c néven.

• sudo nano negyhetszegmens.c

Í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;
  }
  }  
 }      
}

Mentsük el a fájlt, majd GCC paranccsal tegyük futtathatóvá.

• sudo gcc negyhetszegmens.c -o negyhetszegmens -lwiringPi

Végül futtassuk a fájlunkat, ha mindent jól csináltunk elindul a számláló.

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ő.

Programozás

Első lépésként hozzunk létre egy új fájlt ledmatrix.c néven

• sudo nano ledmatrix.c

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

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

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ő.

Programozás

Először hozzunk létre egy új fájlt LCD.c néven.

• sudo nano LCD.c

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;
}

Mentsük el, majd tegyük futtathatóvá a GCC parancs segítségével.

• sudo gcc LCD.c -o LCD -lwiringPi

Végül futtassuk a programot, ha megfelelően kötöttünk mindent, a kijelzőn nulláknak kell megjelennie.

• sudo ./LCD

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ő.

Programozás

Először is hozzunk létre egy új fájlt rgb.c néven.

• sudo nano rgb.c

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;  
}

Mentsük el, majd tegyük futtathatóvá a fájlt a GCC paranccsal.

• sudo gcc rgb.c -o rgb -lwiringPi

Végül futtassuk a programot.

• sudo ./rgb

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ő.

Programozás

Először is hozzunk létre egy új fájlt servo.c néven.

• sudo nano servo.c

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;
}

Ha ezzel megvagyunk, tegyük futtathatóvá a fájlunkat a GCC parancs segítségével.

• sudo gcc servo.c -o servo -lwiringPi

Végül futtassuk a programot.

• sudo ./servo

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ő.

Programozás

Először hozzunk létre egy új fájlt leptetomotor.c néven.

• sudo nano leptetomotor.c

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);
  }
}

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

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

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ő.

Programozás

Először is be kell kapcsolnunk az I2C vezérlő egységet a Raspberry beállításaiban.

• sudo rapsi-config

Itt menjünk az Interfacing Options-ba.

Itt válasszuk ki az I2C pontot, és kapcsoljuk be.

Majd nyomjuk meg kétszer a jobbra nyilat és válasszuk a Finish-t és lépjünk ki.

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

Majd írjuk bele a következő kódot.

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

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.

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ő.

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

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);
			
	}
}

Mentsük el, majd tegyük futtathatóvá a fájlt a GCC paranccsal.

• sudo gcc homero.c -o homero -lwiringPi

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

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ő.

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

Í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);	
	}
}

Mentsük el, majd tegyük futtathatóvá a Raspberry számára a GCC paranccsal.

• sudo gcc potmeter.c -o potmeter -lwiringPi

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

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.

Programozás

Először hozzunk létre egy új fájlt mozgaserzekelo.c néven.

• sudo nano mozgaserzekelo.c

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);
  }
  }	
}

Mentsük el, majd tegyük futtathatóvá a GCC paranccsal.

• sudo gcc mozgaserzekelo.c -o mozgaserzekelo -lwiringPi

Végül futtassuk a fájlt, a megszokott módon.

• sudo ./mozgaserzekelo

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ő.

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

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);
	}
     }

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

Végül futtassuk a fájlt és nézzük meg a végeredményt.

• sudo ./gazerzekelo

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.

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

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;
}

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

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

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.

Programozás

Hozzunk létre egy új fájlt ultrahang.c néven.

• sudo nano ultrahang.c

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;
}

Mentsük el, majd tegyük futtathatóvá a GCC parancs segítségével.

• sudo gcc ultrahang.c -o ultrahang -lwiringPi

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

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.

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

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);
	}
}

Mentsük el, majd tegyük futtathatóvá a GCC parancs segítségével.

• sudo gcc joystick.c -o joystick -lwiringPi

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

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.

Programozás

Első lépésként, hozzunk létre egy új fájlt relay.c néven.

• sudo nano relay.c

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);	  
  }
	
}

Mentsük el, majd tegyük futtathatóvá a GCC paranccsal.

• sudo gcc relay.c -o relay -lwiringPi

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

Bevezetés

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ő.

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

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);			
	}
}

Mentsük el, majd tegyük futtathatóvá GCC paranccsal.

• sudo gcc talajnedvesseg.c -o talajnedvesseg -lwiringPi

Végül futtassuk és nézzük meg milyen értéket ad a talaj nedvességére.

• sudo ./talajnedvesseg