Arduino. Praktika Bilduma

ARDUINOA
PRAKTIKA BILDUMA
J. PARIENTE
2014-2015 IKASTURTEA
AURKIBIDEA
0. HITZAURREA..............................................................................5
1. Sarrera.........................................................................................7
2. Arduino plataforma instalatzea................................................8

2.1. Programa jaitsi
2.2. Programa instalatu
3. Arduino txartel bat martxan jartzea..........................................9

3.1. Txartela konektatu eta kontroladorea instalatu
3.2. Txartela konfiguratu
3.3. Txartela egiaztatu
4. FRITZING...................................................................................15
4.1. Zer da FRITZINGa?
4.2. Zertarako balio du?
4.3. FRITZINGa instalatu
4.4. Diseinuak egiteko erremintak
4.4.1. Protoboarda
4.4.2. Eskema
4.4.3. PCBa
4.5. Diseinuak ekoiztea
P1.1: FRITZINGa. Lehenengo muntaia diseinatzea

P1.2: FRITZINGa. Lehenengo eskema diseinatzea
P1.3: FRITZINGa. Lehenengo PCBa diseinatzea
P2: FRITZING. Bigarren PCBa diseinatzea
P3: FRITZING. Bigarren muntaia bat diseinatzea
5. Arduinoarekin sortutako kodigoa testu-dokumentu batera

esportatzea...............................................................................29
1
PRAKTIKAK..............................................................................................31
1. Blokea: serie-monitorea......................................................................32
1P1 Serie-monitorean kaixo! Inprimatu
1P2 Serie-monitorean formatuak lantzen
1P3 Sarreren eta irteeren datuak bistaratu
1P4 Led bat piztu serie-monitoretik
2. Blokea: sarrera eta irteera digitalak...................................................42

2P1: Sarrera digitala irakurri
2P2: Sarrera-irteera digitalak. Logika digitala
2P3: Aurreko praktika pull-up erresistentzia barik
3. Blokea: sarrera eta irteera analogikoak.............................................52

3P1: Sarrera analogiko bat irakuRRI
3P2: Sarrera analogiko bat irakuRRI. BLINK
3P3: Irteera analogiko bat idatzi
3P4: Balio analogikoak konparatu
4. Blokea: Display-a.................................................................................68
4P1: Displayan testua bistaratu
4P2: Testua bistaratu. Pantaila keinukari
4P3: Serie-monitoretik displayra
4P4: Sarrera-irteeren egoerak displayan bistaratu
5. Blokea: Teklatua...................................................................................82
5P1: Teklatua. Teklatutik serie-monitorean idatzi
5P2: Teklatua. Teklatutik display batean idatzi
5P3: Teklatua. Pin-a eskatu programa exekutatzeko I
5P4: Teklatua. Pin-a eskatu programa exekutatzeko II
2
6. Blokea: Real Time Clock.....................................................................97
6P1: RTCa. Martxan jarri eta konfiguratu
6P2: RTCa. Orduaren formatu berria display batean
6P3: RTCa. Ordua eta dataren arabera irteera bat aktibatu
7. Blokea: Infragorriak...........................................................................107
7P1: IGak. Urrutiko aginteen botoien kodea eskuratu
7P2: IGak. Urrutiko aginte bat testeatu
7P3: IGak. Irteerak aktibatu urrutiko aginte batekin
8. Blokea: Ethernet bidez arduinoa kontrolatu...................................116

8P1 LANa. Sarrera analogikoen balioak online erakutsi
8P2 LANa. Led bat piztu web-orrialde batetik
9. Blokea: Internet bidez arduinoa kontrolatu.....................................131

9P1: Internet. Sarrera analogikoen balioak online erakutsi
9P2: Internet. Led bat piztu web-orrialde batetik
10. Blokea: app bat sortu arduinoa kontrolatzeko.............................149

10P1: app. Sarrera eta irteera digitalak landu
10P2: app. Sarrera eta irteera analogikoak landu
10P3: app. Sarrera eta irteera digitalak. Toggle
10P4: app. Sarrera eta irteera digitalak eta analogikoak
11. Blokea: Bluetooth-a.........................................................................170

11P1: HC05. Txartel bat egiaztatu
11P2: HC05. Txartelarekin led bat piztu
11P3: HC05. Txartela konfiguratu. At komandoak
11P4: HC05. Sarrera analogiko baten balioa smartphonean
11P5. HC05. ARDUDROID
11P6: HC05. BLUETOOTH SPP PRO aplikazioa
11P7: HC05. ATC LITE aplikazioa
3
12. Blokea: RS232 bidez VELLEMAN K8056 kontrolatu.....................178
12P1: K8056. Txartela testeatu

12P2: K8056. Infragorrien bitartez txartela kontrolatu
13. Blokea: MOSFET. Irteeren tentsio balioa egokitu.........................200
13P1: N kanaleko MOSFET “LOGIC LEVEL” bat erabili

13P2: N kanaleko MOSFET arrunt bat erabili
13P3: P kanaleko MOSFET arrunt bat erabili
14. Blokea: datuak gorde SD txartel batean........................................209
14P1: SDa. Testeatu

14P2: SDa. Datuak irakurri eta idatzi
14P3: SDa. Fitxategiak sortu eta ezabatu
14P4: SDa. SD txartelean zer fitxategi dauden erakutsi
14P5: SDa. Sarrera analogikoen balioa gorde
4
HITZAURREA
Ongi etorri Arduinoaren mundura! Esku artean baldin baduzu liburu hau,
esan nahi du Arduinoa landuko duzula. Ezer baino lehen, animo! Lasai hartu,
eta gozatu ezazu!
Zer ezagutza maila behar dut proiektuak egiteko

Zenbait liburutan irakurri dut Arduinoa erabiltzeko ez dagoela zertan
gutxieneko ezagutza batzuk izan. Ideia hori ez da guztiz zuzena. Gertatu liteke
zuk behar duzun proiektua Interneten egotea, eta, beraz, kopiatu eta listo,
badabil! Baina, sarritan, zaila da guk behar dugun proiektu hori topatzea, edo,
agian, ez da existitzen. Hala bada, antzeko proiektu bat hartu daiteke eta
moldatu, eta hor garrantzitsua da nola egin behar den jakitea.
Lehenengo proiektuak egiteko, elektrizitate eta elektronikako gutxieneko
ezagutza batzuk behar dira konexio elektrikoak egin ahal izateko. Ezinbestekoa
da, gainera, programazio hizkuntza bat jakitea, arduinoaren programazioa C
hizkuntzaren antzekoa baita.
Zer topatuko duzu liburu honetan

Liburu honetan Arduino praktiken bilduma bat jaso da. Aukeratu diren
praktiketan, sarrera eta irteera analogiko zein digitalak landu dira. Horiek
ezinbestekoak dira sentsoreak edo eragingailuak erabili ahal izateko.
Liburua, bloketan dago antolatuta. Praktika sinple batekin hasiko da, eta
horren gainean, hobekuntzak edo gehikuntzak egingo dira.
Norentzat da liburu hau

Goi-mailako zikloetako ikasleengan pentsatuta egin da gehien bat;
elektrizitate-elektronika familiako ikasleengan, hain zuzen. Elektronikako gradua
ikasten duten ikasleentzat ere egokia izan daiteke, eta lanbide heziketan
diharduten irakasleentzat ere bai.
5
Zelan erabili liburu hau
Proiektu bati ekin baino lehen, ikasi behar da programaren estruktura
nolakoa den. Bigarrenik, ezinbestekoa da sarrera eta irteera analogiko zein
digitalak menderatzea. Eta, gainera, konexio elektrikoak egiten jakin behar da.
Horretaz gain, garrantzitsua da jakitea serie-monitoreak nola

funtzionatzen duen eta nola erabili behar den gure zereginetarako.
6
1. SARRERA
Arduino open-hardware plataforma da. Sarrera eta irteera (S/I) analogiko eta
digitaletan oinarrituta dagoen plaka bat da, Processing garapen-hizkuntza
erabilita programatua.
Open-hardware-a librea da, eta ondorioz, ez da lizentziarik erosi edo egile-

eskubiderik ordaindu behar ezein proiektu garatzeko.
Gainera, erabiltzen erraza eta ekoizteko merkea denez, gomendagarria da

irakaskuntzan erabiltzeko eta elektronika digitaleko proiektuak garatzeko.
7
2. ARDUINO PLATAFORMA INSTALATZEA
2.1. Programa jaitsi

Programa link honetatik jaitsiko da: http://arduino.cc/en/Main/Software
Gaur egun, IDE 1.6.11 bertsioa dago eskuragarri.
Software hau hainbat sistema eragiletan erabiltzeko prestatuta dago. Jaitsi eta
instalatu besterik ez dago.
2.2. Programa instalatu

Jaitsi ostean, deskonprimatu egin behar da. Windowsen ez du instalaziorik
behar. Deskonprimatu ondoren, karpeta ireki eta arduino fitxategia exekutatuko
dugu programa abiarazteko.
8
3. ARDUINO TXARTEL BAT MARTXAN JARTZEA
3.1. Txartela konektatu eta kontroladorea instalatu

Arduino txartela ordenagailura konektatuko da USB kable bat erabilita.
Arduino UNO txartela USB konexio-kablea
Konexioa egitean, Windows sistema-eragileak esan du ezin dela kontroladorea

instalatu.
Windowsek ez du kontroladorea instalatuko. Eskuz egin beharra dago
Instalazioa egiteko, argazki hauetan ageri diren pausoak jarraitu behar dira:
9
1 Zabaldu: Kontrol-panela / Sistema eta segurtasuna / Sistema / Gailu-
kudeatzailea
2 Beste gailuak jartzen duen tokian, eskumako botoia sakatu eta
Kontrolatzailearen driver-a eguneratu sakatu.
3 Agertuko den leihoan, Arduinoa instalatuta dagoen karpetara joan,
drivers karpetan sartu eta sakatu jarraitu.
4 Instalatu ezazu.
5 Gogoratu behar dugu zein portutan instalatu dugun. Kasu honetan,
COM8 portua da.
1 kontrol-panela / Sistema eta segurtasuna / Sistema / Gailu-kudeatzailea
10
2 Beste gailuak, Kontrolatzailearen driver-a eguneratu.
3 Arduinoaren karpetara joan eta drivers karpetan sartu
11
4 Instalatu ezazu
5 Gogoratu behar dugu zein portutan instalatu dugun. Kasu honetan, COM8 portua da
Hori eginda, txartela instalatuta dago, eta funtzionatzen hasteko gutxieneko

konfigurazio bat egin behar da.
12
3.2. Txartela konfiguratu
Programa abiatzen denean, konfigurazio bi egingo dira:
1 Zer txartel konektatu den esan behar zaio programari:

Bide hau hartuko dugu: Herramientas/Tarjeta/ (Erremintak/txartela/) eta hor
agertuko den zerrendan aukeratuko dugu konektatu den txartela.
2 Non konektatu den arduino txartela ere esan behar zaio programari.
Joan Herramientas/Puerto serial/ (Erremintak/serie-portua/) eta agertuko den
zerrendan dagokion portua adieraziko dugu.
13
3.3. Txartela egiaztatu
Lehenengo, programa kargatu

Aldez aurretik eginda badiren beste programa batzuk ere erabili daitezke.
Gogoratu behar dugu arduino plataforma librea dela! Beraz, hutsetik abiatuta
sortu daitezke aplikazio berriak, edo besteren batek lehenago sortutako
programa batetik abiatuta.
Kasu honetan, egindako programa bat erabiliko dugu txartela egiaztatzeko,
Blink programa hain zuzen ere:
Archivo/Ejercicios/01.Basics/Blink (Fitxategia/Adibideak/01.Basics/Blink)
Blink programa kargatu, eta honako hau konprobatuko dugu: txartelak berak
duen led txiki bat piztu eta itzali egiten dela segundo bateko maiztasunarekin.
Bukatzeko, eta programatutakoa gertatzen dela bermatzeko, aldaketa bat
egingo dugu: oraingoan, segundo bat piztuta eta 100 milisegundo itzalita egon
behar du ledak. Programa berriro kargatu eta programatutakoak funtzionatzen
badu, kitto! Txartela martxan dago!
14
4. FRITZING
4.1. Zer da FRITZNGa?
Arduinorekin muntatuko diren eskema elektrikoak marrazteko balio duen

programa bat da Fritzing. Gainera, programa honekin egindako diseinuak
elektronika libreko diseinuak dira. Programaren egitekoa da diseinugileei
amaierako produktuak sortzen laguntzea, prototipo batetik abiatuta; adibidez,
proba-plakak erabilita.
Hona hemen Arduinorekin egin daitezkeen zenbait adibide. Era honetako

diseinuak erraz topatu daitezke Interneten:
Protoboarda
Eskema elektrikoa
PCBa
15
4.2. Zertarako balio du?
Fritzinga Processing-en eta Arduinoren printzipioetan oinarrituta dago. Arduinon

oinarritutako prototipoak dokumentatzea eta horiek fabrikatzeko zirkuitu
inprimatuen eskemak sortzea errazten du. Gainera, programa honekin plaken
diseinua bera ere aldatu daiteke (gogoan izan Arduino hardware irekia dela).
Fritzingek webgune osagarri bat dauka esperientziak partekatzeko, eta
fabrikazio-kostuak txikiagotzen laguntzen duena.
4.3. Fritzing instalatu
Fritzing instalatzeko, http://fritzing.org/download/ web-orrialdean sartu eta

behar den sistema eragilerako bertsioa deskargatu behar da. Deskonprimatu
eta exekutatu.
4.4. Diseinuak egiteko erremintak
Programa ireki eta eskemak sortzeko hiru erreminta daude:
4.4.1. Protoboarda
Protoboard baten gainean, eskemak egin daitezke. Protoboardean arduinoa,

eta behar den edozein osagai, kokatu eta konektatu besterik ez da egin behar:
zirkuitua diseinatu daiteke koloretako kable eta guzti. Gainera, pantailan
diseinatutako eskema eta muntaia fisikoa berdin-berdinak dira. Programan
zabaltzen den leihoak zati bi ditu: aukerako osagaiena eskuinaldean eta osagai
horiek kokatzeko gunea ezkerraldean. Oinarrizko adibide batekin hastea
gomendatzen da.
16
4.4.2. Eskema
Diseinuak eskema elektriko moduan ere egin daitezke eta itxura horretan
bistaratu.
4.4.3. PCB
Azkeneko modu honek aukera ematen digu zirkuitu elektrikoa eta

protoboardeko diseinua zirkuitu inprimatu (PCB) gisa ikusteko.
4.5. Diseinuak ekoiztea
17
Garatutako diseinua, bukatuta eta frogatuta dagoenean, ekoiztera bidali
daiteke “fabricate” tekla sakatuta.
Egindako diseinua fabrikatzeak zer prezio duen ere ikusi daiteke:

http://fab.fritzing.org/pricing
18
PRAKTIKAK
Helburua
Praktika gidaliburu honetan agertzen diren muntaiak, eskema elektrikoak, eta

PCBak FRITZING programarekin egin izan dira. Diseinu horiek nola egin
ikastea da atal honen helburua.
FRITZING programak Arduinon oinarritutako prototipoak dokumentatzeko balio

du. Gainera, egindako diseinuak fabrikatzeko, zirkuitu inprimatuen eskemak
sortzea errazten du. Horregatik, gidaliburu honetan agertzen diren praktiken
eskemak ikasleak berak berregitea gomendatzen da.
Kapitulu honetan hau ikasiko da:
- Muntaiak protoboard baten gainean diseinatzen

- Arduinoan eraikiko diren eskema elektrikoak diseinatzen
- PCBak era erraz batean diseinatzen
Kapitulu honetan praktika hauek egingo dira:
P2: FRITZINGa. Bigarren PCBa diseinatzea
P3: FRITZINGa. Bigarren muntaia bat diseinatzea
19
1. Helburuak
Sarrera digital bat konektatuko da pultsadore batekin eta pull-down

erresistentzia batekin: 3. pina erabiliko da.
Irteera digital bat konektatuko da led batekin eta erresistentzia batekin: 4. pina
erabiliko da.
A0 sarrera analogikoan potentziometro bat konektatuko da.
2. Prozedura
Programa ireki. Protoboard atalean sakatu. Protoboard bat agertuko da, hutsik.
Eskuinaldean, osagaiak daude. Arduino UNO bat aterako da. Baita led bat,
pultsadore bat, erresistentzia bi eta potentziometro bat ere.
Osagai txikiak, erresistentziak eta ledak protoboardaren gainean kokatuko

ditugu. Osagai handiak, aldiz, plakaren ondoan kokatuko ditugu, hala nola
arduino txartela, displaya, teklatua edo motorra.
Gogoratu, elektronikako beste edozein programatan bezala, komandoak erabili

daitezkeela; adibidez, “control+C” kopiatzeko, edo “control+R” errotazioak
egiteko.
20
Osagaiak kokatuta daude. Erreparatu protoboardak zenbait konexiotan hartu
duen kolore berdeari. Horrek adierazten du, benetako protoboard batean
bezala, zein zulo dauden konektatuta beren artean.
Horrek erraztu egingo du kableak konektatzea. Hurrengo pausoa kableak

jartzea da.
Eskema bat sortzen denean, ahalik eta txukunen egin behar da, eta,
horretarako, osagaiak mugitu, kopiatu, errotatu edo egin beharrekoa egingo da.
Gainera, kableatua egiteko, kable urdinak bakarrik erabili dira. Kableen kolorea
aldatzeak erraztu egingo digu diseinu-lana. Beraz, kableen kolorea aldatuko
dugu. Kableen kolorea irizpide jakin batzuen arabera aldatuko da: Elikadurako
kableak gorriak (+Vcc) eta beltzak (GND) izango dira, eta, normalean,
gainerakoak, urdinak. Baina zenbat eta konplexuagoa izan diseinua, orduan eta
kolore gehiago beharko dira. Eskemak itxura hau hartuko du:
21
1. Helburuak
Aurreko praktikan, zirkuitu bat muntatu dugu protoboard baten gainean.
Oraingoan, praktika beraren eskema elektrikoa egingo dugu.
2. Prozedura
Aurreko praktika berarekin jarraituko dugu. “Eskema” sakatu, eta hor hasiko da
bigarren partea.
Eskema pantailan, aurreko praktikan erabili ditugun osagai guztiak agertuko

dira, desantolatuta. Lehenengo pausoa osagaiak eskeman antolatzea da:
a) b)
a) Eskema pantailan sartzean osagaiak nola agertzen diren

b) Osagaiak antolatuta.
Bigarren pausoa osagaiak kableatzea da. Eskemak itxura hau izan dezake:
22
1. Helburuak
Aurreko praktikan, zirkuitu bat muntatu dugu protoboard baten gainean.

Gainera, eskema elektrikoa ere egin dugu.
Oraingoan, praktika beraren PCBa diseinatuko da.
2. Prozedura
Aurreko praktika berarekin jarraituko dugu. “PCB” sakatu, eta hor hasiko da
praktika honi dagokion partea.
Eskema pantailan, aurreko praktikan erabili diren osagai guztiak agertuko dira,
desantolatuta. Lehenengo pausoa osagaiak eskeman antolatzea da:
Irudian ageri dira, alde batetik, arduino plaka bat, eta bestetik, eraiki nahi den
PCBa. Bien arteko konexioak zuzenean egiten dira. Hau da, ez dago tarteko
konektorerik. Praktika hau egiteko, konektoreak muntatuko dira. Bat plaka
elikatzeko; beste bat, 2 pin digitalentzat; eta azkenengoa, pin
analogikoarentzat:
23
PCBa pantailan, desantolatuta agertuko dira aurreko praktikan erabili diren
osagai guztiak. Lehenengo pausoa osagaiak PCBan antolatzea da. Osagaiak
eraikiko den plakan antolatuko dira. Alde batetik, plaka ahalik eta txikien izan
dadin, eta bestetik, osagaien konexioak ahalik eta laburren izan daitezen.
Gainera, konektoreak, jakina, plakaren alde berean kokatuko dira, kanpoko
kableak erraz konektatu daitezen. Plaka hau proposatzen da:
Azkeneko pausoan, arduinoa kenduko da, plaka neurri egokian moztuko da eta
pistak trazatuko dira:
24
Diseinu hau PDFra esportatuko dugu, eta “copper top” PDFa sortuko da. PDFa
zabalduta, diseinua ikusiko da.
Diseinu hori plaka fabrikatzeko erabiliko da. Plaka ohiko eretan fabrikatu
daiteke:
- Plaka eskuz fabrikatu daiteke. Prototipo bat eraiki eta frogatzeko.

- CNC makina batean eraiki daiteke. Sistema hau erabiltzen da plaka gutxi
behar izanez gero –1-20 ale–.
- 20 plakatik gora behar izanez gero, egindako diseinua enpresa
espezializatu batera bidali daiteke.
- Fritzing programarekin, “Fabricate” sakatuta, programatik bertatik eskatu
daitezke plakak. Prezioak, nahiz eta ale bakar baterako izan, ez dira oso
garestiak:
25
P2: FRITZING. Bigarren PCBa diseinatzea
1. Helburuak
Demagun txip bat egokitu nahi dela arduinoan zuzenean konektatzeko.

Erabiliko den txipa ezkerrean dagoena da. Erabiliko diren 6 pinak eskuineko
argazkian ageri dira. Ordena horretan kokatu behar dira pinen konexioak:
2. Prozedura
Txip generiko bat hartuko da; izan ere, estandarrak dira “IC” txip hauen
neurriak. Txip horren ezaugarrietan pin kopurua aldatu daiteke. Kasu
honetarako, 14 pineko txipa dela esango da.
Konektorea ere estandarra izango da eta horren pin kopurua ere aldatu egin
ahal da. Hauek dira aukeratutako bi osagaiak:
Gogoratu:
Osagaiak eskuineko goiko aldean daude. Osagaia hautatuta, ezaugarriak

aldatu egin daitezke eskuineko beheko leihoan.
26
Osagaiak protoboardaren gainean kokatu:
Kableatzeko, praktikaren helburuetan jaso dugun pin konexioa jarraitu behar

da. Konexioak egin:
Protoboard leihotik PCB leihora pasatuko gara, eta diseinatzen hasiko gara:
27
Osagaiak elkartu, plaka neurrira egin, eta pistak trazatu ondoren, proposatutako
diseinua hau da:
Bukatzeko, diseinua PDF moduan bistaratu daiteke “Export for PDF” eginda,
edota fabrikatzera bidali.
Egindako PCBaren diseinua hau da. Ekoizteko prezioak ere ikusi daitezke.
Aurreko praktikarekin konparatuta, ikusi daiteke plakaren tamainak garrantzia
duela:
28
P3: FRITZING. Bigarren muntaia bat diseinatzea
1. Helburuak
Pultsadore bi, led bi eta potentziometro bi erabiliko dira. Gainera, motor txiki bi
gehituko dira irteera analogikoetan. Pinen banaketa hau da:
Sarrera digitala 1: 2. pina Sarrera digitala 2: 3. pina

Irteera digitala 1: 4. pina Irteera digitala 2: 5. pina
Sarrera analogikoa 1: A0 Sarrera analogikoa 2: A1
Irteera analogikoa 1: 6. pina Irteera analogikoa 2: 9. pina
2. Prozedura
P3 praktika honetan erabiliko diren osagaiak P1.1 praktikan ageri dira. Beraz,
P1.1 praktika berrerabili eta osagaiak gehituko zaizkio, P2 praktika egiteko eta
denbora aurrezteko.
P1.1 praktika ireki, “fitxategia / gorde honela” sakatu eta “P3_protoboard” izena
emango diogu.
Osagaien gainean klik bikoitza egingo da eta osagaien balioak edo

parametroak aldatuko dira: Potentziometroak 100 kΩ-ekoak, leden
erresistentziak 2 kΩ-koak, eta pultsadoreen erresistentziak 10 kΩ-ekoak.
Praktikaren erdia lehendik eginda dago. Osagaiak bikoizteko, “control + C” eta

“control + V” erabiliko dira. Osagaiak protoboardaren gainean ordena logiko
batean kokatuko dira.
Kableatzean, elikadurako kableak gorriak (+Vcc) eta beltzak (GND) izango dira,
analogikoak urdinak, eta digitalak berdeak. Hauxe da egin beharreko muntaia:
29
5. Arduinoarekin sortutako kodigoa testu dokumentu batera
esportatzea
Sarritan gertatzen da –irakasle batek praktika berri bat sortu nahi duenean, edo
ikasle batek txosten bat sortzen duenean…– sortutako kodigoa testu
dokumentu batera esportatu nahi izatea. Kodigo horrek galdu egiten ditu HTML
formatuak dituen koloreak zuzenean kopiatzen bada testu dokumentuan.
Irudian ageri den bezala:
void setup() {
// initialize the digital pin as an output.
pinMode(led, OUTPUT);
pinMode(buttonAlarma, INPUT);
pinMode(buttonResetAlarma, INPUT);
digitalWrite (buttonAlarma, HIGH);
digitalWrite (buttonResetAlarma, HIGH);
Serial.begin(9600);
}
Nahi dugun kodigoa. Koloreekin Kopiatzen den kodigoa. Kolorerik
gabea
Praktikak txukun geratuko zaizkigu irakasleoi eta txostenak kuriosoago ikasleei

Arduino IDE programan sortutako kodigoa koloreek bere horretan irauten
badute. Eta hori erraz lortu daiteke honako pauso hauei jarraituta:
1. Arduino IDE fitxategian kodigoa aukeratu, eskumako botoia sakatu eta

HTML bezala kopiatu:
30
2. Kopiatutako testua, testu fitxategi batean itsatsi (NOTEPAD programan
adibidez). Itxura hau izango du; baina, lasai egon, konbertsio ona egingo
du eta:
3. Ohar-blokean sortutako artxibo hori .html luzapenarekin gorde.
4. Ireki sortutako fitxategia FIREFOXekin. Oraingoan, ikusiko da koloreak

dituela eta itxura egokiarekin ageri dela:
5. Hor agertuko den testua zuzenean kopiatu daiteke eta edozein testu
dokumentutan itsatsi, kolore eta guzti. Hona hemen lortutako emaitza:
void setup() {
// initialize the digital pin as an output.
pinMode(buttonAlarma, INPUT);
pinMode(buttonResetAlarma, INPUT);
digitalWrite (buttonAlarma, HIGH);
digitalWrite (buttonResetAlarma, HIGH);
Serial.begin(9600);
31
PRAKTIKAK
32
1. BLOKEA:
SERIE-MONITOREA
33
1. BLOKEA: SERIE-MONITOREA
Helburua
Arduinoan SERIE-MONITOREA erabiltzen ikastea da.
Oso erabilgarria da serie-monitorea: praktika asko testeatu daitezke gainerako

hardwarea erabili baino lehen: Testeatu egin daitezke, eta geroago konektatu
LCD pantailak, teklatuak, pultsadoreak, bluetooth txartelak eta beste.
Arduinoak serie-portua (RX, TX) edo (0, 1) pinak erabiltzen ditu serieko
transmisioak egiteko.
Arduinoak serieko transmisioa erabiltzen du kodea ordenagailutik arduinora

kargatzeko; ondorioz, RX eta TX LEDak keinuka daude arduinoan kode bat
kargatzen denean.
Serie-monitoreak ere serie-portua erabiliko du arduinoarekin komunikatzeko.
Praktika bilduma honetan egindako ariketa askotan datuak inprimatuko direnez,

praktika bloke hau kontsulta eta gida moduan erabili daiteke serie-monitorea
erabili nahi dugunean.
- Arduinoarekin serie-monitorearekin komunikatzen

- Formatuak erabiltzen
34
P1 SERIE-MONITOREAN KAIXO! INPRIMATU

P2 SERIE-MONITOREAN FORMATUAK LANTZEN
P3 SARREREN ETA IRTEEREN DATUAK BISTARATU
P4 LED BAT PIZTU SERIE-MONITORETIK
35
SERIE-MOITOREA. PRAKTIKAK
1. Helburuak
Bi helburu nagusi daude. Lehenengoa, serie-monitorean datuak inprimatzen

ikastea da.
Bigarrena, sarreraren eta irteera digitalen eta analogikoen egoera pantailan

bistaratzea da; hau da, ikustea pultsadore bat sakatuta dagoen, led bat piztuta
dagoen, tenperatura sentsore batek ematen duen seinalea, haizemaile batek
daukan abiadura... Hori ikasita, serie-monitorea “skada” moduan erabili daiteke,
eta praktika asko konprobatu egin daitezke osagai fisikoak muntatu baino
lehen.
2. Prozedura
Programa kargatu. Serie-monitorea ireki. Serie-monitorean agertzen diren

datuak aztertu eta sartutako kodearekin bat datozela egiaztatu.
3. Materiala
- Arduino Uno plaka bat / protoboard bat / kableak
36
4. Kodeak
1P1 SERIE-MONITOREAN KAIXO! INPRIMATU
/*
Serie-monitorean Kaixo! inprimatu
*/
void setup()
{
Serial.begin(9600);
Serial.println ("Serie-monitorea testeatzen!!!");
}
void loop()
{
Serial.println ("Kaixo!");
delay (2000);
}
37
1P2 SERIE-MONITOREAN FORMATUAK LANTZEN
/*
Praktika honekin serie-monitorean datuak inprimatzen ikasiko da
Serial.print(78); // "78" inprimatuko du
Serial.println(78); // "78" inprimatuko du eta orga-itzulera eragingo du
Serial.println(); // orga-itzulera eragingo du
Serial.print("\t"); // tabuladore bat sartuko du
*/
void setup() {
Serial.begin(9600); // serie-komunikazioa izan
}
void loop() {
Serial.println(78); // "78" inprimatuko du

Serial.println(1.23456); // "1.23" inprimatuko du
Serial.println('N'); // "N" inprimatuko du
Serial.println("Kaixo!!"); // "Kaixo!!" inprimatuko du
Serial.println();
Serial.println(78, BIN); // "1001110" inprimatuko du

Serial.println(78, OCT); // "116" inprimatuko du
Serial.println(78, DEC); // "78" inprimatuko du
Serial.println(78, HEX); //"4E" inprimatuko du
Serial.println();
Serial.println(1.23456, 0); // "1" inprimatuko du

Serial.println(1.23456, 2); // "1.23" inprimatuko du
Serial.println(1.23456, 4); // "1.2346" inprimatuko du
Serial.println();

Serial.print("\t"); // tabuladore bat sartuko du
Serial.print("\t");
Serial.print("3 \t"); // "3" inprimatuko du eta tabuladore bat sartuko du
Serial.println(4); // "4" inprimatuko du
Serial.println();
delay (1000);
38
}
39
1P3 SARREREN ETA IRTEEREN DATUAK BISTARATU
/*
Aldagai analogiko baten balioa inprimatu
Aldagai digital baten balioa inprimatu
Aldagai baten balioa inprimatu
*/
int sarreraAnalogikoa = A0; // A0 sarrera "T1" deituko da.

int irteeraAnalogikoa = 3; // 3. pina irteera analogiko moduan erabiliko da.
int sarreraDigitala = 2;
int irteeraDigitala = 4; // 2. pina irteera digital moduan erabiliko da.
int digitalSarreraBalioa = 0;
int digitalIrteeraBalioa = 0;
int analogSarreraBalioa = 0;
int analogIrteeraBalioa = 0;
void setup() {
// Sarrera eta Irteeren deklarazioa:
pinMode(irteeraAnalogikoa, OUTPUT);
pinMode(sarreraDigitala, INPUT);
pinMode(irteeraAnalogikoa, OUTPUT);
Serial.begin(9600); // serial-komunikazioa izan
}
void loop() {
// Sarrera analogiko bat irakurri (Tenperatura, adibidez). Balioa egokitu: 10 ºC – 40 ºC.
Tenperatura inprimatu:
analogSarreraBalioa = analogRead(sarreraAnalogikoa);
analogSarreraBalioa= map(analogSarreraBalioa, 0, 1023, 10, 40);
Serial.print ("Sarrera Analogikoa = ");
Serial.print (analogSarreraBalioa);
Serial.println (" gradu");
// Irteera analogiko bat irakurri. Balioa egokitu: % 0 - % 100. Portzentajea inprimatu:
analogIrteeraBalioa = 254;
40
analogWrite(irteeraAnalogikoa, analogIrteeraBalioa);
analogIrteeraBalioa = map(analogIrteeraBalioa, 0, 254, 0, 100);
Serial.print ("Irteera Analogikoa = %");
Serial.println (analogIrteeraBalioa);
// Sarrera digital bat irakurri. HIGH edo LOW dagoen inprimatu:
digitalSarreraBalioa = digitalRead(sarreraDigitala);
if(digitalSarreraBalioa == HIGH) {Serial.println ("Sarrera Digitala = 1 ");}
else {Serial.println ("Sarrera Digitala = 0 ");}
// Irteera digital bat irakurri. HIGH edo LOW dagoen inprimatu:
digitalWrite(irteeraDigitala, LOW);
digitalIrteeraBalioa = digitalRead(irteeraDigitala);
if(digitalIrteeraBalioa == HIGH) {Serial.println ("Irteera Digitala = 1 ");}
else {Serial.println ("Irteera Digitala = 0 ");}
Serial.println ();
}
41
1P4 LED BAT PIZTU SERIE-MONITORETIK
/*
Praktika hau HC-05 modulua frogatzeko erabiliko da.
Oraingoan, irteera digital bat piztuko da.
Serie-monitoretik 'p' sakatu 13. LEDa PIZTEKO
Serie-monitoretik 'a' sakatu 13. LEDa AMATATZEKO
Arduinoak datuak RX/TX pinetik jasoko ditu.
*/
char jasoAginduak; // Jasoko diren datuak aldagai honetan gordeko

dira
int led13 = 13; // Piztu/amatatuko dugun LEDa
void setup()
{
pinMode(led13, OUTPUT);
Serial.begin(9600);
Serial.println("Sakatu ezazu p/a LEDa pizteko/amatatzeko!!!");
}
void loop()
{
// Arduinoaren RX/TX serie-portuko bufferrean datuak badaude:
if( Serial.available()>0 ){
jasoAginduak = Serial.read(); // Byte bat irakurri eta aldagaian gorde
// Jasotako bytearen arabera, led bat piztu/amatatu
if(jasoAginduak == 'p' ){digitalWrite(led13, HIGH);
Serial.println("PIN 13 piztuta");}
if(jasoAginduak == 'a' ){digitalWrite(led13, LOW);
Serial.println("PIN 13 amatatuta");}
}
delay(100);
}
42
2. BLOKEA:
SARRERA ETA IRTEERA DIGITALAK
43
2. BLOKEA: SARRERA ETA IRTEERA DIGITALAK
Helburua
Praktika sorta honetan, Arduinoaren oinarrizko konfigurazioak eta konexioak

zein diren eta nola egin landuko da. Batez ere, landuko da arduino-plakaren
sarrera-irteera digitalak nola konfiguratu eta nola funtzionatzen duten.
- Arduinoaren pinak konfiguratzen.

- Serie-monitorea erabiltzen.
- Sarreretan pultsadoreak konektatzen.
- Irteeretan erreleak konektatzen.
2P1: SARRERA DIGITALA IRAKURRI

2P2: SARRERA-IRTEERA DIGITALAK. LOGIKA DIGITALA
2P3: AURREKO PRAKTIKA PULL-UP ERRESISTENTZIA BARIK
44
2P1: SARRERA DIGITALA IRAKURRI
1. Helburuak
2. pina sarrera digital bat izan dadin konfiguratzea.

Pull-up kanpoko erresistentzia konektatzea: pull-up edo pull-down.
Sarrera digitalak irakurtzen jakitea.
Serie-monitorea konfiguratzea, pultsadorea sakatuta dagoen edo ez
bistaratzeko.
2. Prozedura
2. pinari sakatuBotoia izena emango zaio.
Setup errutinan pina konfiguratuko da. 2. pina sarrera digital gisa deklaratuko
da eta serie-komunikazioa hasiko da.
Loop errutinan programa nagusia idatziko da:
Sarrera zer egoeratan dagoen irakurri eta gordeko da. Pultsadorea sakatuta
edo aske dagoen erabaki behar da. Serie-monitorean pultsadorea sakatuta edo
aske dagoela bistaratuko da. Irakurketen artean, denbora tarte bat (delay)
txertatzen da bistaratutakoa lasaiago irakurtzeko.
3. Materiala

- Pultsadorea
- 10 kΩ-eko erresistentzia
45
4. Eskema elektrikoa
5. Oharrak
46
6. Kodigoa
/*
Sarrera digital bat irakurtzea
2. pina sarrera digital gisa konfiguratu. Irakurketa digitalak egingo dira. Serie-monitorean iraku
rketaren emaitzak bistaratuko dira.
*/
// 2. pinak izen hau izango du:

int sakatuBotoia = 2;
// setup errutina behin bakarrik exekutatuko da. Pinak bertan konfiguratu behar dira:
void setup() {
// pin digitala sarrera gisa deklaratuko da:
pinMode(sakatuBotoia, INPUT);
// serial komunikazioa izan:
Serial.begin(9600);
}
// loop errutina behin eta berriro exekutatuko da. Programa nagusia hemen idatziko da:
void loop() {
// sarrera irakurri eta gorde:
int zelanDago = digitalRead(sakatuBotoia);
// sarrera sakatuta edo aske dagoen irakurri:
if (zelanDago == LOW){
Serial.println("Sakatuta!!"); // serie-monitorean pultsadorea sakatuta dagoela inprimatuko da
} else{
Serial.println("Aske!!"); // serie-monitorean pultsadorea aske dagoela inprimatuko da
}
delay(1000); // irakurketen artean denbora tarte bat sartuko da
}
47
2P2: SARRERA-IRTEERA DIGITALAK. LOGIKA DIGITALA
1. Helburuak
Sarrerak irakurriko dira. Irakurketa horien arabera irteera bat idatziko da.
Ariketa honetan, pultsadore bi sakatuta daudenean led bat piztuko da (AND
operadorea: &&). Beste operadore logiko batzuk ere frogatu daitezke.
2. Prozedura
Sarrerak eta irteerak konfiguratuko dira.
Aldagai bi izendatuko dira, eta aldagaiotan gordeko dira egindako irakurketa

digitalak.
Sarrera digitalak irakurriko dira
AND bidezko operazioaren baldintza egiaztatuko da.
Operadorearen arabera, piztu egingo da LEDa, edo ez.
3. Materiala

- Pultsadoreak: 2
- 10 kΩ-eko erresistentziak: 2
48
5. Oharrak
Arduino txartelak led bat dauka integratuta 13. pinean. Lehenengo frogak
egiteko oso ondo dator, konexio gutxiago egin behar direlako.
OPERADORE LOGIKOAK:
AND operadorea: &&
if (zelanDago1 == HIGH && zelanDago2 == HIGH)
OR operadorea : ||
if (zelanDago1 == HIGH || zelanDago2 == HIGH)
NOT operadorea: !
if (!zelanDago1 == HIGH && !zelanDago2 == HIGH)
6. Kodea
/*
Irakurketa digitalak egingo dira. Emaitza hauen arabera irteera bat idatziko da.
Ariketa honetan, sarrera bi hauek piztuta daudenean led bat piztuko da (AND operadorea: &&)
.
Beste operadore logiko batzuk ere frogatu daitezke.
*/
// Sarreren eta irteeraren konfigurazioa egin
const int SakatuBotoia1 = 2; // 2. pinaren izena
const int ledPin = 13; // Arduinoak integratuta duen LEDaren izena
// Aldagaiak:
int zelanDago1 = 0; // Aldagaia irakurketa digitalak gordetzeko.
int zelanDago2 = 0; // Aldagaia irakurketa digitalak gordetzeko.
void setup() {
pinMode(ledPin, OUTPUT); // pin digitala irteera gisa deklaratuko da
pinMode(SakatuBotoia1, INPUT); // pin digitala sarrera gisa deklaratuko da
}
void loop(){ // Sarrera digitalen irakurketak:

zelanDago1 = digitalRead(SakatuBotoia1);
zelanDago2 = digitalRead(SakatuBotoia2);
// AND operadorea frogatuko da:
if (zelanDago1 == HIGH && zelanDago2 == HIGH) {
digitalWrite(ledPin, HIGH); // LEDa piztuko da
}
else {
digitalWrite(ledPin, LOW); // LEDa itzaliko da
}
}
49
2P3: AURREKO PRAKTIKA PULL-UP ERRESISTENTZIA BARIK
1. Helburuak
Sarrerak irakurriko dira. Irakurketa horien arabera, irteera bat idatziko da.
Ariketa honetan, pultsadore bi sakatuta daudenean led bat piztuko da (AND
operadorea: &&). Beste operadore logiko batzuk ere frogatu daitezke.
Praktika honen helburua zirkuitua sinplifikatzea da. Alde batetik, osagai

elektriko gutxiago erabiliko da, eta horretarako, Arduinoaren PULL-UP
erresistentziak aktibatuko dira. Bestetik, ez da erabiliko aldagairik irakurketak
egiteko .
2. Prozedura
Sarrerak eta irteerak konfiguratuko dira.
Konfigurazioan, PULL-UP erresistentziak aktibatuko dira.
Sarrera digitalak irakurriko dira
AND operazioaren baldintza egiaztatuko da.
Operadorearen arabera, piztu egingo da LEDa, edo ez.
3. Materiala

- Pultsadoreak: 2
- 10 kΩ-eko erresistentzia: 0
50
5. Oharrak
Setup konfigurazioan, pull-up erresistentziak aktibatu dira
digitalWrite (SakatuBotoia1, HIGH); // barruko pull-up erresistentzia aktibatzea

Zer lortuko da horrekin?
Pultsadorea sakatuta dagoenean, sarrera 0 izango da.
Pultsadorea sakatuta ez dagoenean, teorian, zarata elektrikoa izango da

sarreran; hau da, 0 edo 1 balioa edo tarteko beste balio bat. Gure praktika
honetan, barruko pull-up erresistentzia aktibatu denez, 1 balioa izango da
sarrera.
EZ da existitzen Pull-down barne erresistentziarik.
Behar izanez gero, NOT operadorea erabili daiteke, irteerak balio egokia izan
dezan.
Praktika honetan, pultsadorearen logika honako hau da: sakatuta 0 eta sakatu
barik 1. Irteera erraz molda daiteke aurreko praktikan bezala funtzionatu dezan:
digitalWrite (ledPin, !(digitalRead (SakatuBotoia1) && digitalRead (SakatuBotoia2)))
51
6. Kodea
/*
Irakurketa digitalak egingo dira. Emaitza hauen arabera irteera bat idatziko da.
Ariketa honetan, sarrera bi hauek piztuta daudenean led bat piztuko da (AND operadorea: &&
)
Beste operadore logiko batzuk ere frogatu daitezke.
BARNE pull-up erresistentziak erabiliko dira.
Irakurketak egiteko ez da aldagairik erabiliko.
*/
// Sarreren eta irteeraren konfigurazioa egin:
const int ledPin = 13; // Arduinoak integratuta duen LEDaren izena
void setup() {
pinMode(ledPin, OUTPUT); // pin digitala irteera gisa deklaratuko da

void loop(){ // LEDa aktibatzeko baldintza: AND operadorea:

digitalWrite (ledPin, (digitalRead (SakatuBotoia1) && digitalRead (SakatuBotoia2)));
}
3.
52
3. BLOKEA:
SARRERA ETA IRTEERA ANALOGIKOAK
53
3. BLOKEA: SARRERA ETA IRTEERA ANALOGIKOAK
Helburua
Praktika sorta honetan, Arduinoaren oinarrizko konfigurazioak eta konexioak

landuko dira. Batez ere, landuko da arduino-plakaren sarrera-irteera
analogikoak nola konfiguratu eta nola funtzionatzen duten.
- Irakurketa analogikoak egiten

- Irteera analogikoak idazten
- Balio analogikoak alderatzen
3P1: SARRERA ANALOGIKO BAT IRAKURRI

3P2: SARRERA ANALOGIKO BAT IRAKURRI. BLINK
3P3: IRTEERA ANALOGIKO BAT IDATZI
3P4: BALIO ANALOGIKOAK KONPARATU
54
TEORIA APUR BAT
Sarrera analogikoak sentsore analogikoen tentsioaren balioak irakurtzeko

erabiliko dira. Arduinoak 6 sarrera analogiko ditu: A0-A5.
Orain arte, logika digitala landu da, eta LOW eta HIGH balioak erabili dira.
Sarrera analogikoen bidez, 0 V-en eta 5 V-en arteko edozein balio lortu
daiteke. Izan ere, 0 V-en eta 5 V-en artean infinitu balio daude; baina,
zenbat balio daude 0-5 V tartean arduino txartel batean? Datu horrek
bihurgailuaren emango du doitasuna.
Bit kopuru ezberdineko bihurgailuak daude. Arduinok duen bihurgailua 10

bitekoa da: sarrera analogikoak balio bat hartzen du eta bihurgailuak 10
biteko zenbaki bihurtzen du. Horrek esan nahi du, 0 -5 V tartean, 10 biteko
bihurgailu batek neurri bereko 2n = 210 = 1024 zati berdinetan banatzen
duela balio analogikoa. Tarte bakoitzak 5 V/1024 = 0.00488 V = 4.88 mV-
eko jausia adieraziko du.
Bit Tarteen zenbatekoa Volt-jausia tarteko
4 2n = 24 = 16 321.5 mV
8 2n = 28 = 256 16.24 mV
10 2n = 210 = 1024 4.88 mV
12 2n = 212 = 4096 1.22 mV
Aurreko taulan, balioak voltetan adierazita besterik ez da ikusten. Baina,

nola bihurtzen dira voltetan adierazitako balio horiek bestelako magnitude
fisiko baten unitateetara, adibidez, gradu zentigradutara? Errazago
ulertzeko, aztertuko dugu bihurgailuak zer lan egiten duen, adibidez,
Tenperaturarekin:
Imajinatu labe elektriko baten tenperatura neurtu nahi dela: 0 - 100 ºC.
Zein da neurketa horren doitasuna?
55
Bit Tarteen zenbatekoa Tenperatura jausiak
tarteko
4 2n = 24 = 16 100 ºC/16 = 6.25 ºC
8 2n = 28 = 256 100 ºC/256 = 0.39 ºC
10 2n = 210 = 1024 100 ºC/1024 = 0.098 ºC
12 2n = 212 = 4096 100 ºC/4096 = 0.024 ºC
Taulan adierazitako jausiei erreparatuta, tenperatura neurtzean, bihurgailuak

irakurketa hauek egingo ditu:
4 bit:
0 6.25 12.5 18.75… ºC
8 bit:
0 0.39 0.78 1.17 1.56 1.95 2.34 2.73 3.12 3.51 3.9 4.29 4.68 5.07… ºC
10 bit:
0 0.098 0.196 0.294 0.392 0.49 0.588 0.686 0.784 0.882 0.98 1.078… ºC
12 bit:
0 0.024… 0.984 1.008… ºC
Datu horiek ikusita, bistan dago bihurgailuaren doitasuna. Neurketaren

garrantziaren arabera, 1 ºC neurtzeko, 4 biteko bihurgailua ez da egokia,
6.25 ºC-ko saltoak ematen baititu. 8 bitekoa onargarria izan daiteke edo ez,
behar den doitasunaren arabera. Askoz egokiagoak dira, beraz, 10 bitekoa,
0.098 ºC-ko jausiak ematen dituelako, eta 12 bitekoa, 0.024 ºC-koak ematen
dituelako.
Irakurketa analogiko bat egiteko 100 mikrosegundo behar dira. Horregatik,
komeni da irakurketen artean denbora tartetxo bat itxarotea, edo
Serial.begin() funtzioaren bidez irakurketa-abiadura definitzea.
56
3P1: SARRERA ANALOGIKO BAT IRAKURRI
3. Helburuak
Potentziometro bat erabilita, 0 V-en eta 5 V-en arteko balio analogikoak

irakurriko dira eta serie-monitorean bistaratuko dira. Egindako irakurketak
0ren eta 1.023ren tartean egongo dira. Irakurritako balioak voltetan ere
emango dira.
4. Prozedura
A0 sarrera analogikoari “potentziometroa” izena emango zaio.
Setup errutinan, pina konfiguratuko da eta serie-komunikazioa egongo dela
adieraziko da. A0 pina ez da deklaratu behar sarrera analogiko gisa, horixe
bakarrik izan daitekeelako: sarrera eta analogikoa.
Loop errutinan, programa nagusia idatziko da: sarrera zer egoeratan dagoen
irakurri eta gordeko da. Irakurritako balioa serie-monitorean bistaratuko da:
ºC-tan eta voltetan. Irakurketen artean denbora tarte bat sartuko da
inprimatutakoa astiroago bistaratzeko.
5. Materiala

- 10 kΩ-eko potentziometroa
57
7. Oharrak
58
8. Kodea
/*
SARRERA ANALOGIKO BAT IRAKURRI
Potentziometro bat erabilita, 0 eta 5 V tarteko balio analogikoak ne
urtuko dira.
Irakurritako balioak serie-monitorean bistaratuko dira.
Egindako irakurketak 0 V = 0 eta 5 V = 1023 izango dira eta tarteko
balio guztiak.
Irakurritako balioak voltetan ere emango dira.
*/
int potentziometroa = A0; // A0 sarrera "potentziometroa" deituko

da.
float PotBalioa = 0; // potentziometroan egindako
irakurketak "PotBalioa" aldagaian gordeko dira.
void setup() {
}
void loop() {
PotBalioa = analogRead(potentziometroa); // Potentziometroan
dagoen tentsioa irakurri
// serie-monitorean egindako irakurketa analogikoak bistaratuko
dira:
Serial.print("POTENTZIOMETROAREN IRAKURKETA: ");
Serial.print(PotBalioa, 0); // Irakurketa inprimatu
Serial.print("\t");
Serial.print("VOLTIO: ");
Serial.print(PotBalioa*5/1023, 4); // Bihurketa, emaitza voltetan
izateko. Emaitza 4 hamartarrekin emango da.
Serial.println("V");
delay (1000); // Irakurketak segundo bateko
tartearekin egingo dira.
}
59
3P2: SARRERA ANALOGIKO BAT IRAKURRI. BLINK
1. Helburuak
Praktika honek aurrekoaren antza du. Kasu honetan, irakurritako balio

analogikoak led keinukari batek zer maiztasunez egiten duen ñir-ñir
adieraziko du: zenbat denboraz egongo den piztuta eta zenbatez itzalita.
2. Prozedura

Setup errutinan, pina konfiguratuko da eta serie-komunikazioa egongo dela
adieraziko da. A0 pina ez da deklaratu behar sarrera analogiko gisa.
potentziometroa (sarera) zer egoeratan dagoen irakurri eta gordeko da.
Irteeran LED bat egongo da keinuka. LEDaren maiztasuna potentziometroan
irakurritako balioa izango da. Hau da, potentziometroarekin lortu daiteke
keinukaria (LEDa) arinago edo motelago piztea.
3. Materiala
- Arduino Uno plaka bat/ protoboard bat / kableak

60
5. Kodea
/*
LED keinukari bat sortuko da.
LEDak zein maistasunez egiten duen keinu
potentziometro batetik irakurritako balio analogikoa da.
*/
int potentziometroa = A0; // A0 sarrera "potentziometroa" deituko da.

int LED = 13; // 13. pina erabiliko da LEDa aktibatzeko
int PotBalioa = 0; // potentziometroan egindako irakurketak "PotBalioa"
aldagaian gordeko dira.
void setup() {
// LED pina irteera izango da:
pinMode(LED, OUTPUT);
}
void loop() {
// Potentziometroan dagoen tentsioa irakurri eta gorde:
PotBalioa = analogRead(potentziometroa);
// LEDa piztu eta itzali:
digitalWrite(LED, HIGH);
delay(PotBalioa);
digitalWrite(LED, LOW);
delay(PotBalioa);
}
61
3P3: IRTEERA ANALOGIKO BAT IDATZI.
1. Helburuak
SARRERA ANALOGIKO BAT IRAKURRI eta haren balioa IRTEERA

ANALOGIKO batean idatziko da.
Potentziometro bat erabilita, 0 V eta 5 V tarteko balio analogikoak neurtuko
dira. Irakurritako balioak irteera analogiko batean idatziko dira.
Egindako irakurketak 0 V = 0 eta 5 V = 1.023 izango dira, eta tarteko balio
guztiak. Egindako idazketak 0 V = 0 eta 5 V = 254 izango dira, eta tarteko
guztiak.
2. Prozedura

PWM 3. pinari AO3 izena emango zaio.
Setup errutinan pina konfiguratuko da. Ez da deklaratu behar A0 pina
sarrera analogiko moduan; eta AO3 pina irteera analogiko gisa deklaratuko
dugu.
potentziometroa zer egoeratan dagoen irakurri eta gordeko da. Balio hori
irteera analogiko batera eramango da.
Balioa mapeatu edo egokitu egingo da:
PotBalioa = map(PotBalioa, 0, 1023, 0, 254);
3. Materiala

62
5. Oharrak
63
6. Kodea
/*
SARRERA ANALOGIKO BAT IRAKURRI eta haren balioa IRTEERA ANALOG
IKO batean idatzi
Potentziometro bat erabilita, 0 V -5 V tarteko balio analogikoak neurtuko dira
Irakurritako balioak Irteera analogiko batean idatziko dira.
Egindako irakurketak 0 V = 0 eta 5 V = 1.023 izango dira, eta tarteko balio
guztiak.
Egindako idazketak 0 V = 0 eta 5 V = 254 izango dira, eta tarteko guztiak.
*/
float potentziometroa = A0; // A0 sarrera "potentziometroa" deituko da.

float AO3 = 3; // 3. pina irteera analogikoa moduan erabiliko da.
float PotBalioa = 0; // potentziometroan egindako irakurketak "PotBalioa"
aldagaian gordeko dira.
float PotBalioaVoltiotan = 0; // potentziometroan egindako irakurketak
"PotBalioa" aldagaian gordeko dira.
void setup() {
// LED pina irteera izango da:
pinMode(AO3, OUTPUT);
}
void loop() {
PotBalioa = analogRead(potentziometroa);
PotBalioa = map(PotBalioa, 0, 1023, 0, 254);
PotBalioaVoltiotan = PotBalioa*5/254;
Serial.println (PotBalioaVoltiotan, 4); // Bihurketaren emaitza voltetan izateko.
Emaitza 4 hamartarrekin emango da.
delay (500);
analogWrite(AO3, PotBalioa);
}
64
3P4: BALIO ANALOGIKOAK KONPARATU.
1. Helburuak
Gela bateko tenperatura kontrolatu behar da. Sentsore analogiko bi erabiliko

dira: T1 eta T2. Irakurriko dituzten tenperaturak 10 ºC-ren eta 40 ºC-ren artean
egongo dira. Sentsore biek tenperatura antzerako bat neurtu behar lukete.
Funtzionamenduak baldintza hauek beteko ditu:
T1 – T2 ≥ 2 ºC edo T1 – T2 ≤ 2 ºC LED BERDEA PIZTU
T1 – T2 ≥ 3 ºC edo T1 – T2 ≤ 3 ºC HAIZAGAILUA % 25eko abiaduran PIZTU
T1 – T2 ≥ 5 ºC edo T1 – T2 ≤ 5 ºC HAIZAGAILUA % 50eko abiaduran PIZTU
T 1– T2 ≥ 5 ºC edo T1 – T2 ≤ 5 ºC HAIZAGAILUA % 100eko abiaduran PIZTU
T 1– T2 ≥ 10 ºC edo T1 – T2 ≤ 10 ºC ALARMA PIZTU
2. Prozedura
Bi sarrera analogikoak konfiguratu.
Bi irteera digitalak konfiguratu.
Bi irteera analogikoak konfiguratu.
Tenperaturak konparatu eta horren arabera irteerak aktibatu
3. Materiala

- Pultsadorea
65
5. Oharrak
Konparazio-operadoreak
Aldagaien edo konstanteen arteko konparazioak if estrukturekin egiten
dira. Konparazio-operadoreak hauek dira:
x == y // x y-ren berdina
x != y // x y-ren desberdina
x<y // x y baino txikiagoa
x>y // x y baino handiagoa
x <= y // x y baino txikiagoa edo berdina
x >= y // x y baino handiagoa edo berdina
if (x > 120) digitalWrite(LEDpin, HIGH);
66
6. Kodea
/*
Gela bateko tenperatura kontrolatu behar da. Tenperatura-sentsore anal
ogiko bi erabiliko dira: T1 eta T2.
Irakurriko dituzten tenperaturak 10 ºC-ren eta 40 ºC-
ren artean egongo dira.
Sentsore biek tenperatura antzerako bat neurtu behar lukete. Funtziona
menduak baldintza hauek beteko ditu:
T1-T2 ≥ 2 ºC edo T1-T2 ≤ 2 ºC LED BERDEA PIZTU
T1-T2 ≥ 3 ºC edo T1-T2 ≤ 3 ºC HAIZAGAILUA % 25eko
abiaduran PIZTU
abiaduran PIZTU
abiaduran PIZTU
T1-T2 ≥ 10 ºC edo T1-T2 ≤ 10 ºC ALARMA PIZTU
*/
int T1 = A0; // A0 sarrera "T1" deituko da.

int T2 = A1; // A1 sarrera "T2" deituko da.
int ledBerdea = 2; // 2. pina irteera digital moduan erabiliko da.
int Alarma = 4; // 4. pina irteera digital moduan erabiliko da.
int haizEmailea = 3;// 3. pina irteera analogiko moduan erabiliko da.
int haizeBalioa = 0;
float T1Balioa = 0; // Lehenengo tenperaturaren irakurketa: T1
float T2Balioa = 0; // Lehenengo tenperaturaren irakurketa: T2
void setup() {
// irteeren deklarazioa:
pinMode(ledBerdea, OUTPUT);
pinMode(Alarma, OUTPUT);
pinMode(haizEmailea, OUTPUT);
}
void loop() {
T1Balioa = analogRead(T1);
T2Balioa = analogRead(T2);
T1Balioa= map(T1Balioa, 0, 1023, 10, 40);
T2Balioa= map(T2Balioa, 0, 1023, 10, 40);
if (T1Balioa - T2Balioa >= 2) {

digitalWrite(ledBerdea, HIGH);
digitalWrite(Alarma, LOW);
analogWrite(haizEmailea, 0);
}

digitalWrite(ledBerdea, LOW);
haizeBalioa = 1+254/4;
}

67
haizeBalioa = 254/2;
}
digitalWrite(Alarma, HIGH);
haizeBalioa = 254;
}
analogWrite(haizEmailea, haizeBalioa);
haizeBalioa= map(haizeBalioa, 0, 254, 0, 100);
Serial.print ("T1=");
Serial.print (T1Balioa);
Serial.print (", T2=");
Serial.print (T2Balioa);
Serial.print (", T1- T2 =");
Serial.print (T1Balioa-T2Balioa);
Serial.print (", HAIZE EMAILEA = %");
Serial.println (haizeBalioa);
if(digitalRead(ledBerdea) == HIGH) {Serial.println ("Led Berdea = 1

");} else {Serial.println ("Led Berdea = 0 ");}
if(digitalRead(Alarma) == HIGH) {Serial.println ("Alarma = 1 ");}
else {Serial.println ("Alarma = 0 ");}
Serial.println ();
}
68
4. BLOKEA:
DISPLAYa
69
4. BLOKEA: DISPLAYa
Helburua
Arduinoari DISPLAY bat erantsiko zaio, eta praktika batzuk egingo dira
maneiatzen ikasteko.
Pantailan datuak bistaratu daitezke. Horrek dakartzan abantailak handiak dira,

eta era guztietako datuak ikus daitezke, hala nola tenperatura-balio bat, ate bat
irekita dagoen edo ez, tanke baten nibela...
- Arduinoari DISPLAY bat konektatzeko nolako konexio-motak dauden

- <LiquidCrystal.I2C.h> liburutegia gehitzen
- DIPLAYa kontrolatzeko behar diren komandoak erabiltzen
4P1: DISPLAYan TESTUA BISTARATU

4P2: TESTUA BISTARATU. PANTAILA KEINUKARI
4P3: SERIE-MONITORETIK DISPLAYRA
4P4: SARREREN-IRTEEREN EGOERAK DISPLAYAN BISTARATU
70
DISPLAY BAT ARDUINOAN KONEKTATU
Konexio mota bi daude:
PARALELO-KONEXIOA:
Erraza da konektatzen, baina 9 pinen soldadurak egin behar dira.
Kontrolatzeko instalatu behar den liburutegia hau da: <LiquidCrystal.h>
DISPLAYA ARDUINOA
RS 12
Enable 11
D4 5
D5 4
D6 3
D7 2
SERIE-KONEXIOA
Gaur egun, plaka txiki bat jartzen zaio LCD pantailari, I2C bihurgailua deritzona.
Horrek PARALELO konexioa SERIE bihurtzen du:
SERIE-konexioa konektatzen errazena da. Ez da soldadurarik egin behar, eta,

horregatik, erabiliena da. 4 kable konektatu behar dira, eta, hori egin ondoren,
prest dago datuak bistaratzeko. Izan ere, serie-konexioak arduinoaren bi
sarrera analogiko besterik ez du erabiltzen. Paraleloak, ordea, 6 sarrera/irteera
digitalak erabiltzen ditu eta potentziometroa ere konektatu behar da.
71
Kontrolatzeko instalatu behar den liburutegia hau da: <LiquidCrystal_I2C.h>
DISPLAY ARDUINO
GND GND
Vcc +5V
SDA A4
SCL A5
LIBURUTEGI BERRI BAT INSTALATU

1. pausoa
Web orrialde honetatik LCD DISPLAYa kontrolatzeko liburutegia jaitsi eta
gorde. https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads
Liburutegia hau da: LiquidCrystal_V1.2.1.zip
2. pausoa
Liburutegi hau Arduino IDE programan instalatu behar da. Horretarako,
liburutegia inportatzeko agindu behar diogu programari: Sketch/ Importar
Librería / Add Library… sakatu behar da. Jaitsitako liburutegia bilatu eta
instalatzeko bai sakatu.
72
Praktika hauetan erabiliko den eskema elektrikoa
Displaya arduinoan konektatzeko egin behar diren konexioak hauek dira:
DISPLAYA ARDUINOA
GND GND
Vcc +5V
SDA A4
SCL A5
73
4P1: DISPLAYan TESTUA BISTARATU
1. Helburuak
Praktika honetan testu bat bistaratuko da displayan. Pantailaren lehenengo

lerroan, kurtsorea kokatu behar da eta “Kaixo!” idatzi. Pantailaren bigarren
lerroan, kurtsorea kokatu eta “Ze moduz?” idatzi. Serie-konexioa erabiliko da.
2. Prozedura
Behar diren liburutegiak instalatu (bloke honen hasieran azalduta dago); baina

erabiltzeko, eta komandoak erabilgarri egoteko, liburutegiak deitu egin behar
ditugu programatik:
#include <Wire.h> // Liburutegi hau instalatuta dator Arduino IDE programan

#include <LiquidCrystal_I2C.h>
// I2C txipak zein pin erabiltzen dituen adierazi:
// addr, en,rw,rs,d4,d5,d6,d7,bl,blpol
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // LCD I2C

helbidea idatzi
Kurtsorea kokatu eta mezua bidaliko dugu.
3. Materiala
- Arduino Uno bat / protoboard bat / kableak

- 16 x 2-ko display bat
74
4. Kodea
/*Praktika honetan, mezu bat bistaratuko da 16 x 2-ko DISPLAYan
Display mota hau erabiliko da: 16 karaktereko eta 2 lerroko I2C Displaya
Atzean LCM1602A IIC V1" interfacea du. Lau kable besterik ez da konektatu behar.
*/
/*-----( Behar diren liburutegiak inportatu )-----*/
// DISPLAYrako liburutegia instalatu beharra dago. LCD I2C liburutegia hemendik jaitsiko da:
// https://bitbucket.org/fmalpartida/new-liquidcrystal/downloads
// Beste LCD liburutegirik badago, ezabatu egin behar dira edo beste toki batera mugitu.
// Liburutegian, begiratu "Docs" karpeta erabili daitekeen komandoak ikusteko.
/*-----( Konstanteak deklaratu )-----*/
// LCDaren helbidea; 0 x 27 jarri 20 karaktere eta 4 lineako displayrako
// I2C txipak zein pin erabiltzen dituen adierazi:
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // LCD I2C helbidea idatzi
/*-----( Aldagaiak deklaratu )-----*/
void setup() /*----( SETUP: Behin exekutatzen da )----*/

{
// Serie-monitorea abiaraziko da. Hemendik, DISPLAYra bidaliko dira inprimatuko diren karakte
reak:
Serial.begin(9600);
lcd.begin(16,2); // LCDa hasieratu 16 karaktere eta 2 lerrorako. Horrekin argia ere piztuko da
}
void loop() /*----( LOOP: behin eta berriro exekutatzen da )----*/

{
lcd.setCursor(0,0); //Lehenengo karakterea lehenengo lerrokoa
lcd.print("Kaixo!!"); // Mezu bat bidali
lcd.setCursor(0,1); //Lehenengo karakterea bigarren lerrokoa
lcd.print("Ze moduz zabiz?"); // Mezu bat bidali
}
75
4P2: TESTUA BISTARATU. PANTAILA KEINUKARI
1. Helburuak
Praktika hau aurrekoa bezalakoa da: Mezu bat bistaratuko da 16 x 2-ko

DISPLAYan
Pare bat aldaketa izango du: argia piztu eta itzali egingo da eta pantaila
garbitzen ikasiko da.
Display mota hau erabiliko da: 16 karaktereko eta 2 lerroko I2C Displaya
2. Prozedura
Behar diren liburutegiak instalatu (bloke honen hasieran azalduta dago); baina

erabiltzeko, eta komandoak erabilgarri egoteko, liburutegiak deitu egin behar
ditugu programatik:

// I2C txipak zein pin erabiltzen dituen jarri:
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // LCD I2C

helbidea idatzi
Pantaila piztu eta amatatu 3 alditan.

Kurtsorea kokatu eta mezua bidali.
3. Materiala
- Arduino Uno bat / protoboard bat / kableak

- 16 x 2-ko display bat
76
4. Oharrak
5. Kodea
/* Praktika hau aurrekoa bezalakoa da: Mezu bat bistaratuko da 16 x
2-ko DISPLAYan.
Pare bat aldaketa izango du: argia piztu eta itzali egingo da eta p
antaila garbitzen ikasiko da.
Display mota hau erabiliko da: 16 karaktereko eta 2 lerroko I2C Dis
playa
Atzean LCM1602A IIC V1" interfazea du. Lau kable besterik ez da kon
ektatu behar.
*/
#include <Wire.h> // Hau instalatuta dator Arduino IDE programan
// Bestea ez dator. Instalatu beharra dago. LCD I2C Liburutegia hemen
dik jaitsiko da:
// Beste LCD liburutegirik badago, ezabatu egin behar
dira edo beste toki batera mugitu.
// Liburutegian, begiratu "Docs" karpeta erabili daitekeen komandoak i
kusteko.
// LCDaren helbidea; 0 x 27 jarri 20 karaktere eta 4 lineako displayra
ko
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // LCD
I2C helbidea idatzi

{
// Serie-monitorea abiaraziko da. Hemendik, DISPLAYra bidaliko dira in
primatuko diren karaktereak:
Serial.begin(9600);
lcd.begin(16,2); // LCDa hasieratu 16 karaktere eta 2 lerrorako.
77
Honekin argia ere piztuko da
// ------- argia keinukari 3 alditan -------------
for(int i = 0; i< 3; i++)
{
lcd.backlight();
delay(500);
lcd.noBacklight();
delay(500);
}
lcd.backlight(); // bukaeran argia piztuta utzi
//-------- Karaktereak idatzi DIPLAYan erakusteko ------------------
// OHARRA: Kurtsorearen kokalekua (KARAKTEREA, LERROA) 0n hasiko da
lcd.setCursor(0,0); //Kurtsorea (0, 0) kokalekuan kokatu: 1go lerroa
delay(1000);
lcd.print("Kaixo, Mundua!"); // Mezu bat bidali
delay(1000);
lcd.setCursor(0,1); //Kurtsorea (0, 1) kokalekuan kokatu: 2. lerroa
delay(3000);
}

{
delay(500);
// pantaila garbitu
lcd.clear();
lcd.setCursor(0,0);
lcd.print("KAIXO,");
delay(500);
lcd.setCursor(8,0);
lcd.print("MUNDUA!!");
delay(500);
lcd.clear();
lcd.setCursor(0,1);
lcd.print("KAIXO,");
lcd.setCursor(8,1);
delay(500);
lcd.print("MUNDUA!!");
delay(500);
for(int i = 0; i< 3; i++)

{
lcd.backlight();
delay(500);
lcd.noBacklight();
delay(500);
}
lcd.backlight();
}
78
4P3: SERIE-MONITORETIK DISPLAYRA
1. Helburuak
Praktika honetan, SERIE-MONITOREAN idazten diren karaktereak DISPLAYan

bistaratuko dira enter tekla sakatzen denean.
2. Materiala
- Arduino Uno plaka bat/ protoboard bat/ kableak

- Pultsadorea
3. Kodea
/* 3. praktika honetan SERIE-MONITOREAN idazten dena DISPLAYan bistara
tuko da.
Display mota hau erabiliko
da: 16 karaktereko eta 2 lerroko I2C Displaya
Atzean LCM1602A IIC V1" interfazea du. Lau kable besterik ez da kon
ektatu behar.
*/
// Bestea ez dator. Instalatu beharra dago. Hemendik, LCD I2C Liburute
gia jaitsiko da:
// Beste LCD liburutegirik badago, ezabatu egin behar
dira edo beste toki batera mugitu.
// Liburutegian, begiratu "Docs" karpeta erabili daitekeen komandoak i
kusteko.
// LCDaren helbidea 0 x 27 jarri 20 karaktere eta 4 lineako displayrak
o
I2C helbidea idatzi

{
// Serie-monitorea abiaraziko da. Hemendik, DISPLAYra bidaliko dira in
primatuko diren karaktereak:
79
Serial.begin(9600);
lcd.begin(16,2); // LCDa hasieratu 16 karaktere eta 2 lerrorako.
Horrekin, argia ere piztuko da
// ------- argia keinukari 3 alditan -------------
for(int i = 0; i< 3; i++)
{
lcd.backlight();
delay(250);
lcd.noBacklight();
delay(250);
}
lcd.backlight(); // bukaeran argia piztuta utzi
//-------- Karaktereak idatzi DIPLAYan erakusteko ------------------
// OHARRA: Kurtsorearen kokalekua (KARAKTEREA, LERROA) 0n hasiko da
lcd.print("Kaixo, Mundua!"); // Mezu bat bidali
delay(1000);
delay(3000);
// Itxaron eta erabiltzailearentzat mezu berri bat bidali:
// Serie-Monitorea abiarazi. Karaktereak idatzi eta displayan bistarat
u
lcd.clear();
lcd.setCursor(0,0); //Lehenengo karakterea lehenengo lerrokoa
lcd.print("SerieMon Erabili"); // Mezu bat bidali
lcd.setCursor(0,1);
lcd.print("Idatzi eta intro"); // Mezu bat bidali
}

{
{
// karaktereak heltzen direnean serie atakara
if (Serial.available()) {
// itxoin apur batean mezu osoa heldu arte
delay(100);
// pantaila garbitu
lcd.clear();
// read all the available characters
while (Serial.available() > 0) {
// display each character to the LCD
lcd.write(Serial.read());
}
}
}
}
80
4P4: SARREREN ETA IRTEEREN EGOERAK DISPLAYAN
BISTARATU
1. Helburuak
Praktika honetan, sarrerak eta irteerak zein egoeratan dauden bistaratuko da

DISPLAYan; hau da: 0 logikoa edo 1 logikoa duten.
Bistaratuko diren Sarrerak S1, S2 eta S3 izango dira.
Bistaratuko diren Irteerak I1, I2 eta I3 izango dira.
Programak, funtzio logiko hauek beteko ditu:
S1·S2 = I1
S1+S2 = I2
S1·S2·S3 = I3
2. Prozedura
Aurreko praktiketako prozedura bera jarraitu behar da.
Kurtsorea non kokatuko den eta zer bistaratuko den gehitu behar da.
Sarreren eta irteeren egoera, 0 edo 1, irakurri behar da eta displayan inprimatu.
3. Materiala
- Arduino Uno plaka bat/ protoboard bat/ kableak

- Pultsadorea
81
4. Kodea
/* 4. praktika honetan sarrera digitalen egoeraren arabera bidaliko dira mezuak

DISPLAYra
S sarrerak dira. I Irteerak dira. Besteak operadore logikoak.
Sarreren eta irteeren egoerak bistaratuko dira DISPLAYan.
S1 AND S2 = I1
S1 OR S2 = I2
S1 AND S2 AND S3 = I3
*/

//Sarrerak esleitu:
const int S1=2; const int S2=3; const int S3=4;
//Irteerak esleitu:
const int I1=5; const int I2=6; const int I3=7;
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // LCD I2C helbidea
idatzi

{
//Sarrerak eta irteerak deklaratu:
pinMode(S1, INPUT); pinMode(S2, INPUT); pinMode(S3, INPUT);
pinMode(I1, OUTPUT); pinMode(I2, OUTPUT); pinMode(I3, OUTPUT);
// barruko pull-up erresistentzia aktibatzea

digitalWrite (S1, HIGH);
// pin digitalak irteera gisa deklaratuko dira

lcd.begin(16,2); // LCDa hasieratu
lcd.backlight(); // Argia piztu
// OHARRA: Kurtsorearen kokalekua (KARAKTEREA, LERROA) hasiko da

delay(1000);
lcd.print("Kaixo!"); // Mezu bat bidali
delay(1000);
lcd.print("Programa martxan!"); // Mezu bat bidali
lcd.clear();
delay(1000);
}

{
// Operadore logikoak aplikatu:
digitalWrite (I1, (digitalRead (S1) && digitalRead (S2)));
digitalWrite (I2, (digitalRead (S1) || digitalRead (S2)));
digitalWrite (I3, (digitalRead (S1) && digitalRead (S2) && digitalRead (S3)));
// Sarrerak 0/1 diren DISPLAYan bistaratu:

lcd.setCursor(0,0); lcd.print ("S1="); lcd.print (digitalRead (S1));
// Irteerak 0/1 diren DISPLAYan bistaratu:

lcd.setCursor(0,1); lcd.print ("I1="); lcd.print (digitalRead (I1));
delay(400);
}
82
5. BLOKEA:
TEKLATUA
83
5. BLOKEA: TEKLATUA
Helburua
Arduinoari TEKLATU bat erantsiko zaio eta praktika batzuk egingo dira
erabiltzen ikasteko.
Teklatuarekin arduinoan datuak edo komandoak exekutatu daitezke. Horrek

dakartzan abantailak handiak dira, hala nola ate bat irekitzea, motor bati
eragitea, eta bururatu daitekeen edozer piztea.
- Teklatua egiaztatzen
- Arduinoari TEKLATU bat konektatzeko zer konexio mota dauden
- <keypad.h> liburutegia gehitzen
- TEKLATUTIK bidalitako datuak interpretatzen
5P1: TEKLATUA. TEKLATUTIK SERIE-MONITOREAN IDATZI

5P2: TEKLATUA. TEKLATUTIK DISPLAY BATEAN IDATZI
5P3: TEKLATUA. PINA ESKATU PROGRAMA EXEKUTATZEKO I
5P4: TEKLATUA. PINA ESKATU PROGRAMA EXEKUTATZEKO II
84
TEKLATU BATEN KONEXIOAK EGIAZTATU
Teklatua 4x4 matrize bat da; 4 lerro eta 4 zutabe.
Polimetro batekin edozein teklaturen konfigurazioa egiaztatu daiteke.

Polimetroa jarraitasun moduan jarrita, aurreko irudian ageri den teklatu-
modeloan, teklatuan sakatzen den teklaren arabera, jarraitasuna izango du
kable hauetan:
TEKLA LERROA ZUTABEA KABLEAK

'1' 1 1 1-5
'2' 1 2 1-6
'3' 1 3 1-7
'4' 2 1 2-5
'5' 2 2 2-6
'6' 2 3 2-7
'7' 3 1 3-5
'8' 3 2 3-6
'9' 3 3 3-7
'0' 4 2 4-6
'A' 1 4 1-8
'B' 2 4 2-8
'C' 3 4 3-8
'D' 4 4 4-8
'*' 4 1 4-5
'#' 4 3 4-7
85
TEKLATU BAT ARDUINOAN KONEKTATU ETA KONFIGURATU
Teklatua arduinoan konfiguratuko da. Teklatuko 4 lerroak erabiliko dira eta 3

zutabe: Kasu honetan, letrak baztertuko dira: 4x3 matrizea konfiguratuko da.
Lehenengo eta behin, aukeratuko da zein pinetan konektatuko den teklatua.

Kasu honetan, teklatua konektatzeko erabiliko diren pinak 2tik 8ra izango dira: 7
kable erabiliko dira (4x3 matrizea) eta ez 8 (4x4 matrizea). Beheko koadroan
jaso den kodigoa 4x3 matrizerako prestatuta dago. Kodigoa ikusita, aldaketa
txiki batzuekin, erraz asmatu daiteke zelan konfiguratu daitekeen 4x4 teklatu
bat, edo 2x4koa, edo behar dena:
const byte linea = 4; //lau lerro

const byte zutabe = 3; //hiru zutabe
char teklak[linea][zutabe] = {
{'1','2','3'},
{'4','5','6'},
{'7','8','9'},
{'*','0','#'}
};
//teklatuaren lerroen kableak zein pinetan konektatuko dira
byte lineaPins[linea] = {5, 4, 3, 2};
//teklatuaren lerroen kableak zein zutabeetan konektatuko dira
byte zutabePins[zutabe] = {8, 7, 6};
Keypad teklatua = Keypad( makeKeymap(teklak), lineaPins, zutabe Pins, linea, zutabe);
Konexio elektrikoak teklatutik arduinora:
86
TEKLATU BAT ARDUINOAN PROGRAMATU
Teklatua erabiltzeko “keypad.h” liburutegia jaitsi eta instalatu behar da.
DISPLAYarekin egin zen era berean. Liburutegia hemendik jaitsi daiteke:
http://playground.arduino.cc/code/Keypad
Orain, programa berri bat egiterakoan, liburutegia aipatu behar da:

#include <Keypad.h>
Teklatuan agertzen diren karaktereak nahi direnak izan daitezke. Pegatina bat
besterik ez da. Matrizean ere, pegatinan dauden karaktereak idatzi daitezke
edo ez:
{'1','2','3','4','5'} {'<','>'}, 1. argia piztu/itzali {'1 ON','1 OFF'}, 1. argia piztu/itzali
, {'<','>'}, 2. argia piztu/itzali {'2 ON','2 OFF'}, 2. argia piztu/itzali
{'6','7','8','9','0'} {'<','>'} 3. argia piztu/itzali {'3 ON','3 OFF'} 3. argia piztu/itzali
,
{'+','-','*','/','='}
Jarraian ikusi daitezke merkatuan dauden teklatu motak. Horiek erabiltzen

dituzten karaktereak nahi den eran aldatu daitezke matrizean:
87
PRAKTIKAK
5P1: TEKLATUA. TEKLATUTIK SERIE-MONITOREAN IDATZI
1. Helburuak
Teklatutik sakatzen diren teklak serie-monitorean bistaratuko dira. Teklatuaren

lerro guztiak erabiliko dira eta hiru zutabe (4x3 matrizekoa).
Praktika honetan, letrak baztertu egingo dira.
2. Prozedura
Teklatu matriziala konfiguratuko da: 4x3 matrizea
Teklatua arduinoan konektatuko da.
Serie-monitorea abiaraziko da.
Teklak eskuratuko dira: “tekla = teklatua.getKey()” eta serie-monitoretik

inprimatuko dira: “Serial.print(tekla);”
3. Materiala

- Teklatu bat (4x4 matrizekoa)
88
4. Kodea
/* Teklatuan sakatzen diren teklak serie-monitorean bistaratuko dira.
Erabiliko den teklatua 4x4 matrizekoa izango da baina 4x3 erabiliko da.
Letrak baztertuko dira.
*/
#include <Keypad.h>
const byte lerro = 4; //lau lerro

const byte zutabe = 3; //hiru zutabe
char teklak[lerro][zutabe] = {
{'1','2','3'},
{'4','5','6'},
{'7','8','9'},
{'*','0','#'}
};
byte lerroPins[lerro] = {8, 7, 6, 5}; //Ordenan: L1, L2, L3, L4
byte zutabePins[zutabe] = {4, 3, 2}; //Ordenan: Z1, Z2, Z3
Keypad teklatua = Keypad( makeKeymap(teklak), lerroPins, zutabePins, lerro, zutabe );
char tekla;
int zenbakia;

{
// Serie-monitorea abiaraziko da:
Serial.begin(9600);
}
void loop() /*----( LOOP: behin ta berriro exekutatzen da )----*/

{
tekla = teklatua.getKey(); //teklatuan sakatutako tekla eskuratu
if(tekla != NO_KEY){
zenbakia = tekla - 48; //tekla ASCII karaktere bat da. Zenbaki bihurtu
Serial.print(tekla);
}
}
89
5P2: TEKLATUA. TEKLATUTIK DISPLAY BATEAN IDATZI
1. Helburuak
Teklatutik sakatzen diren teklak DISPLAYan bistaratuko dira. Teklatuaren lerro

eta zutabe guztiak erabiliko dira (4x4 matrizekoa).
Praktika honetan, letrak ere erabiliko dira.
2. Prozedura
Teklatu matriziala konfiguratuko da: 4x4 matrizea
Teklatua arduinoan konektatuko da.
DISPLAYa abiaraziko da.
Teklak eskuratuko dira: “char tekla = teklatua.getKey();”
eta DISPLAYtik inprimatuko dira: “lcd.print(tekla);”
3. Materiala

- 16x2 display bat
90
4. Kodea
/* Teklatuan sakatzen diren teklak DISPLAYan bistaratuko dira.
Erabiliko den teklatua 4x4 matrizekoa izango da.
*/
#include <Keypad.h>
#include <Wire.h> // for I2C LCD
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

const byte zutabe = 4; //Lau zutabe
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
byte zutabePins[zutabe] = {5, 4, 3, 2}; //Ordenan: Z1, Z2, Z3, Z4
int count=0;
char tekla;
void setup()
{
Serial.begin(9600);
lcd.begin(16, 2);
lcd.print("Teklatua");
lcd.print("testeatzen!");
delay(2000);
lcd.clear();
lcd.print("Teklak sakatu");
lcd.print("itzazu!!");
delay(2000);
lcd.clear();
}
void loop()
{
char tekla = teklatua.getKey();
if (tekla != NO_KEY)
{
lcd.print(tekla);
count++;
if (count==17)
{
lcd.clear();
count=0;
}
}
}
91
92
5P3: TEKLATUA. PIN ESKATU PROGRAMA EXEKUTATZEKO I
1. Helburuak
Programa erraz bat exekutatzea da helburua: LED bat piztea edo amatatzea.
Programa exekutatzeko, PIN bat eskatuko da: 1234.
'*' edo '#' teklekin programatik aterako da, eta PINa berriro sartu beharko da.
DISPLAYaren bitartez, informazioa bistaratuko da: Ongi etorri / PIN zenbakia

eskatu / Programa: RUN / Programa: STOP.
2. Prozedura
3. Materiala

- 16x2 display bat
93
4. Kodea
#include <Keypad.h>
int posizioa = 0;
int gorri = 10;
int berde = 11;
// boolean locked;
char* kodigoSekretua = "1234";

{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
Keypad teklatua = Keypad( makeKeymap(teklak), lerroPins, zutabePins, lerro,
zutabe );
void setup()
{
Serial.begin(9600);
pinMode (gorri, OUTPUT);
pinMode (berde, OUTPUT);
programaNagusia(false);
lcd.begin(16, 2);
lcd.print(" ONGI ETORRI!!"); delay(2000); lcd.clear();
lcd.print(" Mesedez,"); lcd.setCursor(0,1);
lcd.print(" Sartu PINa:"); delay(2000); lcd.clear();
}
void loop()
{
if (tekla == '*' || tekla == '#')
{ posizioa = 0; programaNagusia(false); }
if (tekla == kodigoSekretua[posizioa])

{ posizioa ++; }
if (posizioa == 4)
{ programaNagusia(true); }
delay(100);
94
}
boolean programaNagusia(int martxan)

//Aurreko guztia kodigoa sartzeko izan da.
//Hemen, ohiko programa idatziko da:
{
if (martxan)
{ digitalWrite (gorri, LOW);
digitalWrite (berde, HIGH);
lcd.clear(); lcd.print(" PIN Sartuta!!");
lcd.print(" PROGRAMA: RUN");
}
else
{ digitalWrite (gorri, HIGH);
digitalWrite (berde, LOW);
lcd.clear(); lcd.print(" Sartu berriro!!");
lcd.print(" PROGRAMA: STOP");
}
}
5. OHARRAK
Programa ez da oso egokia. Adibidez, 1111222333444 kodigoa sartzen bada,

1234 balitz bezala hartuko du. Eta 91929394 sartuta ere, 1234 hartuko du.
Alde batetik, ez du kopuru mugarik zenbakiak sartzeko.
Bestetik, 1234 zenbakiak agertzen badira, nahiz eta tartekatuta egon –

01020304 adibidez–, PIN zenbakia onartuko du.
Horregatik guztiarengatik, programa hau hobetu egingo da P4 bertsioan.
95
5P4: TEKLATUA. PINA ESKATU PROGRAMA EXEKUTATZEKO
II
1. Helburuak
Hirugarren praktika hobetzea da helburua. Alde batetik, 4 zenbaki sartuko direla

kontrolatuko da.
PIN berri bat sartu behar bada, aurretik, '*' tekla sakatu behar da zenbatzailea
berrabiarazteko. PIN berria sartu denean, PINa konprobatzeko, '#' tekla sakatu behar
da “ENTER” izango balitz bezala.
Programa hau luzeegia denez, funtzioen bitartez egituratuko da.
2. Prozedura
Programa antolatzeko bost funtzio berri eraikiko dira:
void zuzenPIN() void gaizkiPIN() void konprobatuPIN()
void irakurriTeklatua() boolean programaNagusia(int martxan)
Lehenengo teklatua irakurriko da “void irakurriTeklatua()”. Teklatutik jaso diren

datuekin, PINa konprobatuko da “void konprobatuPIN()”. PINa zuzena den edo
ez erabakiko da eta dagokion funtziora salto egingo da “void zuzenPIN()” edo
“void gaizkiPIN()”.
PINa zuzena bada, “martxan = true;” balioa pasatuko zaio “boolean

programaNagusia(int martxan)” funtzioari.
PINa zuzena ez bada, “martxan = false;” balioa pasatuko zaio “boolean

programaNagusia(int martxan)” funtzioari.
3. Materiala

96
- 16x2 display bat
97
4. Kodea
// PIN bat eskatuko da programa bat exekutatu baino lehen.
// PIN hau zuzena denean, programa nagusi bat exekutatuko da (hasteko led bat piztuko da).
// PIN hau zuzena ez denean, programa nagusia ez da exekutatuko (hasteko led bat amatatuko
da).
// Programaren egoera DISPLAY batean bistaratuko da. Ongi etorria/PIN zuzena/ez zuzena
#include <Keypad.h>
const byte lerro = 4; //Lau lerro

{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
char PIN[4]={'1','1','1','1'}; // gure zenbaki sekretua

char egiaztatzaile[4]={0,0,0,0};
int z=0;
int led = 13;
boolean martxan = false;
void setup()
{
Serial.begin(9600);
lcd.begin(16, 2);
lcd.print("ONGI ETORRI!!"); delay(2000); lcd.clear();
lcd.print("Mesedez,"); lcd.setCursor(0,1);
lcd.print("Sartu PINa:"); delay(2000);
}
void loop()
{
irakurriTeklatua();
programaNagusia(martxan);
}
void irakurriTeklatua()
{
if (tekla != NO_KEY)
{ switch(tekla)
{
case '*': z=0; break; // Z hasieratu behar da PIN berri bat sartzeko
case '#': delay(100); // # sakatu beharra dago PINa egiaztatzeko.
konprobatuPIN(); break;
default: egiaztatzaile[z]=tekla; z++;
98
}
}
}
void konprobatuPIN()
{
int zuzen=0; int i;
for ( i = 0; i < 4 ; i++ )
{
if (egiaztatzaile[i]==PIN[i]) {zuzen++;}
}
if (zuzen==4) {zuzenPIN();}
else {gaizkiPIN();}
for (int zz=0; zz<4; zz++) // hasieran sartutako kodea ezabatuko du
{egiaztatzaile[zz]=0;}
}
void zuzenPIN() // Hau exekutatu PINa zuzena bada

{
lcd.clear();
lcd.print("PIN zuzena!!");
lcd.setCursor(0,1); lcd.print("Programa: RUN");
martxan = true;
}
void gaizkiPIN() // Hau exekutatu PINa zuzena ez bada

{
lcd.clear();
lcd.print("PIN ez da zuzena!");
lcd.setCursor(0,1); lcd.print("Sartu PINa:");
martxan = false;
}
boolean programaNagusia(int martxan)

{ //Hemen programa nagusia idatziko da.
//martxan= true denean, programa exekutatuko da.
//martxan= false denean, programa nagusia ez da exekutatuko.
if (martxan)
{
digitalWrite (led, HIGH);
}
else
{
digitalWrite (led, LOW);
}
}
99
6. BLOKEA:
REAL TIME CLOCK
100
6. BLOKEA: REAL TIME CLOCK
Helburua
Zenbait proiektutan, interesgarria izaten da gauzak orduaren arabera

kontrolatzea. Adibidez, etxe baten kanpoko argia piztu, astelehenetik ostiralera,
argi nahikorik ez denean, edo, lorategi bat ureztatzea egunero goizeko
2:00etatik goizeko 6:00ak arte.
Praktika hauen helburua orduaren eta dataren menpe dagoen irteera digital bat
kontrolatzea da.
- Arduinoari RTC modulu bat konektatzen

- Kodea jaitsi eta moldatzen
- Ordua eta data zehazten
- Irteera digital bat pizten orduaren eta dataren arabera
6P1: RTC. MARTXAN JARRI ETA KONFIGURATU

6P2: RTC. ORDUAREN FORMATU BERRIA DISPLAY BATEAN
6P3: RTC. ORDUA ETA DATAREN ARABERA, IRTEERA BAT AKTIBATU
101
6P1: RTC. MARTXAN JARRI ETA KONFIGURATU
1. Helburuak
Lehenengo praktikaren helburua kodea lortzea da eta RTC erlojua martxan

jartzea. Kodea exekutatzen denean arduinoan, ordua eta data egokitu egingo
dira eta serie-monitorean bistaratuko dira.
2. Prozedura
Kodea esteka honetatik jaitsi behar duzu:
http://playground.arduino.cc/Main/DS1302
Kodearen zati hau bilatu eta dagokion data eta ordua idatzi:
Adibidez, 10:00:00 2014/10/26
// Bete itzazu aldagai hauek behar den ordu eta datarekin:
int seconds, minutes, hours, dayofweek, dayofmonth, month, year;
// Adibidez, 10:00:00 2014/10/26, asteko 7. eguna.

// Aldagai hauetan, jar ezazu nahi duzun data eta ordua:
seconds = 0;
minutes = 0;
hours = 10;
dayofweek = 7; // asteko eguna 1...7
dayofmonth = 26; // Hileko eguna, 1...31
month = 10; // Hila 1...12
year = 2014; // Urtea
Kodea arduinoan kargatu eta serie-monitorea ireki.
Hona hemen serie-monitorean zein formatutan ikusiko diren ordua eta data.
Bost segundoko maiztasunarekin agertuko dira ordu eta data berriak:
102
3. Materiala

- RTC Modulo bat: DS1302
5. Oharrak
Errazena da PCB txiki batean muntatuta erostea hauek guztiak: konektorea,

DS1302 txipa, osziladorea eta bateria. Hau da erabili den modulua:
Merkatuan hainbat modelo dago. Nahiz eta konexioak antzekoak izan, egokitu
egin behar dira eta arreta handiarekin irakurri behar da produktuaren
deskripzioa:
103
104
6P2: RTC. ORDUAREN FORMATU BERRIA DISPLAY BATEAN
1. Helburuak
Helburua da ordua eta data formatu honekin bistaratzea DISPLAY batean:
10:00:27 => ordua:minutuak:segundoak
2014-10-26 E = 7 => urtea-hila-eguna E = asteko eguna
2. Prozedura
Jatorrizko kodean, bilatu ezazu zati hau eta egin aldaketa hauek:
sprintf( buffer, "Ordua = %02d:%02d:%02d, ", \

bcd2bin( rtc.h24.Hour10, rtc.h24.Hour), \
bcd2bin( rtc.Minutes10, rtc.Minutes), \
bcd2bin( rtc.Seconds10, rtc.Seconds));
Serial.print(buffer);
Jatorrizko kodea
sprintf(buffer, "Data(eguna) = %d, Hila = %d, " \
"Asteko eguna = %d, Urtea = %d", \
bcd2bin( rtc.Date10, rtc.Date), \
bcd2bin( rtc.Month10, rtc.Month), \
rtc.Day, \
2000 + bcd2bin( rtc.Year10, rtc.Year));
Serial.println( buffer);
delay( 5000);
sprintf( buffer, "%02d:%02d:%02d", \
Kodigoa aldatuta lcd.setCursor(0,0);
lcd.print(buffer);
sprintf(buffer, "%d-%d-%d E=%d", \
2000 + bcd2bin( rtc.Year10, rtc.Year), \
rtc.Day);
lcd.setCursor(0,1);
lcd.print(buffer);
delay( 1000);
105
106
3. Materiala

- 16x2-ko display bat
- RTC modulu bat: DS1302
I2C display bat konektatu:
DISPLAYa ARDUINOa
GND GND
Vcc +5V
SDA A4
SCL A5
RTC modulu bat konektatu:
107
5. Kodea
Kode hau oso luzea denez, egin beharreko aldaketak aipatuko ditugu:
I2C display bat instalatuko denez, dagokion kodea gehituko da.

void loop() funtzioan, prozeduran azaldutako kodea aldatuko da:
#include <Wire.h> // Hau Arduino IDE programan instalatuta dator

I2C helbidea idatzi
…
void setup()
{
lcd.begin(16,2); // LCDa hasieratu
}
void loop()
{
lcd.setCursor(0,0);
lcd.print(buffer);
rtc.Day);
lcd.setCursor(0,1);
lcd.print(buffer);
delay( 1000);
108
6P3: RTC. ORDUAREN ETA DATAREN ARABERA AKTIBATU
IRTEERA BAT
1. Helburuak
Praktika honen helburua irteera digital bat piztea da. Kasu honetan, orduaren
eta dataren menpe dagoen irteera bat kontrolatuko da. Aurreko praktika
berrerabili genezake. Baita aurreko eskema elektrikoa ere.
2. Prozedura
Jatorrizko kodean, bilatu ezazu zati hau eta egin aldaketa hauek:
lcd.setCursor(0,0);
lcd.print(buffer);
Jatorrizko kodea bcd2bin( rtc.Month10, rtc.Month), \
rtc.Day);
lcd.setCursor(0,1);
lcd.print(buffer);
delay( 1000);
// HEMEN ALDAGAIAK ERABILIKO DIRA ORDUAREN ETA DATAREN

FORMATUAREKIN EROSOAGO LAN EGITEKO
ordua = bcd2bin( rtc.h24.Hour10, rtc.h24.Hour);
minutuak = bcd2bin( rtc.Minutes10, rtc.Minutes);
segundoak = bcd2bin( rtc.Seconds10, rtc.Seconds);
urtea = 2000 + bcd2bin( rtc.Year10, rtc.Year);
hila= bcd2bin( rtc.Month10, rtc.Month);
Kodea aldatuta eguna = bcd2bin( rtc.Date10, rtc.Date);
astekoEguna = rtc.Day;
// NON BISTARATUKO DIREN ERE ESANGO DA: SERIE-MONITOREAN ETA

DISPLAY BATEAN
DS1302_clock_burst_read( (uint8_t *) &rtc);
ordua, \
minutuak, \
segundoak);
lcd.setCursor(0,0);
lcd.print(buffer);
urtea, \
hila, \
eguna, \
astekoEguna);
lcd.setCursor(0,1);
109
lcd.print(buffer);
3. Materiala

- 16x2-ko display bat
- RTC modulu bat: DS1302
4. Kodea
Kode honek bi azpikode ditu, eta bakoitzak eginkizun bat du esleituta. Biak
frogatuko dira. Azpikodeetako bat gaituta dagoenean bestea ez da egongo, eta
aldrebes (// kenduta edo jarrita):
- LEDa 2 minutu egongo da piztuta, 22:15etik 22:17ra.

- LEDa astelehen eta ostegunetan piztuko da, 22:00etatik 00:00ak arte
// IRTEERAK DEKLARATU. BAITA PROGRAMAN ERABILIKO DIREN PARAMETROAK ERE
int LED13 = 13;
int ordua; int minutuak; int segundoak;
int urtea; int hila; int eguna; int astekoEguna;
…
void setup()
{
// Orduaren eta dataren arabera piztuko diren irteerak deklaratu:
pinMode(LED13, OUTPUT); // pin digitala irteera gisa deklaratuko da
digitalWrite (LED13, LOW);
}
…
void loop()
{
// HEMEN ALDAGAIAK ERABILIKO DIRA ORDUAREN ETA DATAREN FORMATUAREKIN LAN
EGITEKO
ordua = bcd2bin( rtc.h24.Hour10, rtc.h24.Hour);
minutuak = bcd2bin( rtc.Minutes10, rtc.Minutes);
segundoak = bcd2bin( rtc.Seconds10, rtc.Seconds);
urtea = 2000 + bcd2bin( rtc.Year10, rtc.Year);
hila= bcd2bin( rtc.Month10, rtc.Month);
eguna = bcd2bin( rtc.Date10, rtc.Date);
astekoEguna = rtc.Day;
// ESANGO DA NON BISTARATU: SERIE-MONITOREAN ETA DISPLAY BATEAN

DS1302_clock_burst_read( (uint8_t *) &rtc);
ordua, \
minutuak, \
segundoak);
lcd.setCursor(0,0);
110
lcd.print(buffer);
urtea, \
hila, \
eguna, \
astekoEguna);
lcd.setCursor(0,1);
lcd.print(buffer);
//LED bat aktibatzea baldintzen arabera, kasu honetan, ORDUAREN arabera:

//LEDa 2 minutu egongo da piztuta, 22:15etik 22:17ra:
//if (((ordua >= 22) && (minutuak >= 15)) && ((ordua <= 22) && (minutuak <=
16))) {digitalWrite (LED13, HIGH);}
//else {digitalWrite (LED13, LOW);}
//LED bat aktibatzea baldintzen arabera, kasu honetan, DATAREN eta ORDUAREN
arabera:
//LEDa astelehen eta ostegunetan piztuko da, 22:00etatik 00:00ak arte:
if ((ordua >= 22) && ((astekoEguna == 1)|| (astekoEguna == 4)))
{digitalWrite (LED13, HIGH);}
else {digitalWrite (LED13, LOW);}
delay(1000);
}
Zalantzarik badago, hemen dago kode osoa. Letra oso txikia denez, ez dago
irakurtzerik, baina kopiatu egin daiteke eta IDE programan itsatsi:
// Orduaren edota dataren arabera, irteera digital bat aktibatuko da.
// Lehenengo kasua: LED bat aktibatzea 2 minutu, 22:15etik 22:17ra void loop()
// Bigarren kasua: LED bat aktibatzea astelehen eta ostegunetan, 22:00etatik 00:00ak arte {
ds1302_struct rtc;
// DS1302 RTC char buffer[80]; // the code uses 70 characters.
// ----------
// // HEMEN ALDAGAIAK ERABILIKO DIRA ORDUAREN ETA DATAREN FORMATUAREKIN LAN EGITEKO
// Open Source / Public Domain ordua = bcd2bin( rtc.h24.Hour10, rtc.h24.Hour);
// minutuak = bcd2bin( rtc.Minutes10, rtc.Minutes);
// Version 1 segundoak = bcd2bin( rtc.Seconds10, rtc.Seconds);
// By arduino.cc user "Krodal".
// June 2012 urtea = 2000 + bcd2bin( rtc.Year10, rtc.Year);
// Using Arduino 1.0.1 hila= bcd2bin( rtc.Month10, rtc.Month);
// Version 2 eguna = bcd2bin( rtc.Date10, rtc.Date);
// By arduino.cc user "Krodal" astekoEguna = rtc.Day;
// March 2013
// Using Arduino 1.0.3, 1.5.2 // NON BISTARATUKO DEN ERE ESANGO DA: SERIE-MONITOREAN ETA DISPLAY BATEAN
// The code is no longer compatible with older versions. DS1302_clock_burst_read( (uint8_t *) &rtc);
// Added bcd2bin, bin2bcd_h, bin2bcd_l
// A few minor changes. sprintf( buffer, "%02d:%02d:%02d", \
// ordua, \
// minutuak, \
// Documentation: datasheet segundoak);
// Serial.print(buffer);
// The DS1302 uses a 3-wire interface: lcd.setCursor(0,0);
// - bidirectional data. lcd.print(buffer);
// - clock
// - chip select sprintf(buffer, "%d-%d-%d E=%d", \
// It is not I2C, not OneWire, and not SPI. urtea, \
// So the standard libraries can not be used. hila, \
// Even the shiftOut() function is not used, since it eguna, \
// could be too fast (it might be slow enough, astekoEguna);
// but that's not certain). Serial.println( buffer);
// lcd.setCursor(0,1);
// I wrote my own interface code according to the datasheet. lcd.print(buffer);
// Any three pins of the Arduino can be used.
// See the first defines below this comment, //LED bat aktibatzea baldintzen arabera, kasu honetan, ORDUAREN arabera:
// to set your own pins. //LEDa 2 minutuz egongo da piztuta, 15. eta 16. minutuak:
// //if (((ordua >= 22) && (minutuak >= 15)) && ((ordua <= 22) && (minutuak <= 16))) {digitalWrite (LED13, HIGH);}
// The "Chip Enable" pin was called "/Reset" before. //else {digitalWrite (LED13, LOW);}
//
// The chip has internal pull-down registers. //LED bat aktibatzea baldintzen arabera, kasu honetan, DATAREN eta ORDUAREN arabera:
// This keeps the chip disabled, even if the pins of //LEDa astelehen eta ostegunetan piztuko da, 22:00etatik 00:00ak arte:
// the Arduino are floating. if ((ordua >= 22) && ((astekoEguna == 1)||(astekoEguna == 4))) {digitalWrite (LED13, HIGH);}
// else {digitalWrite (LED13, LOW);}
//
// Range
// ----- delay(1000);
// seconds : 00-59 }
// minutes : 00-59
// hour : 1-12 or 0-23 // --------------------------------------------------------
// date : 1-31 // DS1302_clock_burst_read
// month : 1-12 //
// day : 1-7 // This function reads 8 bytes clock data in burst mode
// year : 00-99 // from the DS1302.
// //
// // This function may be called as the first function,
// Burst mode // also the pinMode is set.
// ---------- //
// In burst mode, all the clock data is read at once. void DS1302_clock_burst_read( uint8_t *p)
// This is to prevent a rollover of a digit during reading. {
// The read data is from an internal buffer. int i;
//
// The burst registers are commands, rather than addresses. _DS1302_start();
// Clock Data Read in Burst Mode
// Start by writing 0xBF (as the address), // Instead of the address,
// after that: read clock data // the CLOCK_BURST_READ command is issued
// Clock Data Write in Burst Mode // the I/O-line is released for the data
// Start by writing 0xBE (as the address), _DS1302_togglewrite( DS1302_CLOCK_BURST_READ, true);
// after that: write clock data
// Ram Data Read in Burst Mode for( i=0; i<8; i++)
// Start by writing 0xFF (as the address), {
// after that: read ram data *p++ = _DS1302_toggleread();
// Ram Data Write in Burst Mode }
// Start by writing 0xFE (as the address), _DS1302_stop();
// after that: write ram data }
//
// // --------------------------------------------------------
// Ram // DS1302_clock_burst_write
// --- //
// The DS1302 has 31 of ram, which can be used to store data. // This function writes 8 bytes clock data in burst mode
// The contents will be lost if the Arduino is off, // to the DS1302.
// and the backup battery gets empty.
// It is better to store data in the EEPROM of the Arduino. //
// The burst read or burst write for ram is not implemented // This function may be called as the first function,
// in this code. // also the pinMode is set.
// //
// void DS1302_clock_burst_write( uint8_t *p)
// Trickle charge {
// -------------- int i;
// The DS1302 has a build-in trickle charger.
// That can be used for example with a lithium battery _DS1302_start();
// or a supercap.
// Using the trickle charger has not been implemented // Instead of the address,
// in this code. // the CLOCK_BURST_WRITE command is issued.
// // the I/O-line is not released
_DS1302_togglewrite( DS1302_CLOCK_BURST_WRITE, false);
#include <Wire.h> // Hau Arduino IDE programan instalatuta dator
#include <LiquidCrystal_I2C.h> for( i=0; i<8; i++)
// addr, en,rw,rs,d4,d5,d6,d7,bl,blpol {
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // LCD I2C helbidea idatzi // the I/O-line is not released
_DS1302_togglewrite( *p++, false);
// IRTEERAK DEKLARATU. BAITA PROGRAMAN ERABILIKO DIREN PARAMETROAK ERE }
int LED13 = 13; _DS1302_stop();
int ordua; int minutuak; int segunduak; }
int urtea; int hila; int eguna; int astekoEguna;
// Set your own pins with these defines ! // --------------------------------------------------------
#define DS1302_SCLK_PIN 6 // Arduino pin for the Serial Clock // DS1302_read
#define DS1302_IO_PIN 7 // Arduino pin for the Data I/O //
#define DS1302_CE_PIN 8 // Arduino pin for the Chip Enable // This function reads a byte from the DS1302
// (clock or ram).
//
// Macros to convert the bcd values of the registers to normal // The address could be like "0x80" or "0x81",
// integer variables. // the lowest bit is set anyway.
// The code uses seperate variables for the high byte and the low byte //
// of the bcd, so these macros handle both bytes seperately. // This function may be called as the first function,
#define bcd2bin(h,l) (((h)*10) + (l)) // also the pinMode is set.
#define bin2bcd_h(x) ((x)/10) //
#define bin2bcd_l(x) ((x)%10) uint8_t DS1302_read(int address)
{
uint8_t data;
// Register names.
// Since the highest bit is always '1', // set lowest bit (read bit) in address
// the registers start at 0x80 bitSet( address, DS1302_READBIT);
// If the register is read, the lowest bit should be '1'.
#define DS1302_SECONDS 0x80 _DS1302_start();
#define DS1302_MINUTES 0x82 // the I/O-line is released for the data
#define DS1302_HOURS 0x84 _DS1302_togglewrite( address, true);
#define DS1302_DATE 0x86 data = _DS1302_toggleread();
#define DS1302_MONTH 0x88 _DS1302_stop();
#define DS1302_DAY 0x8A
#define DS1302_YEAR 0x8C return (data);
#define DS1302_ENABLE 0x8E }
#define DS1302_TRICKLE 0x90
#define DS1302_CLOCK_BURST 0xBE
#define DS1302_CLOCK_BURST_WRITE 0xBE // --------------------------------------------------------
#define DS1302_CLOCK_BURST_READ 0xBF // DS1302_write
#define DS1302_RAMSTART 0xC0 //
#define DS1302_RAMEND 0xFC // This function writes a byte to the DS1302 (clock or ram).
#define DS1302_RAM_BURST 0xFE //
#define DS1302_RAM_BURST_WRITE 0xFE // The address could be like "0x80" or "0x81",
#define DS1302_RAM_BURST_READ 0xFF // the lowest bit is cleared anyway.
//
// This function may be called as the first function,
// also the pinMode is set.
// Defines for the bits, to be able to change //
// between bit number and binary definition. void DS1302_write( int address, uint8_t data)
// By using the bit number, using the DS1302 {
// is like programming an AVR microcontroller. // clear lowest bit (read bit) in address
// But instead of using "(1<<X)", or "_BV(X)", bitClear( address, DS1302_READBIT);
// the Arduino "bit(X)" is used.
#define DS1302_D0 0 _DS1302_start();
#define DS1302_D1 1 // don't release the I/O-line
#define DS1302_D2 2 _DS1302_togglewrite( address, false);
#define DS1302_D3 3 // don't release the I/O-line
#define DS1302_D4 4 _DS1302_togglewrite( data, false);
#define DS1302_D5 5 _DS1302_stop();
#define DS1302_D6 6 }
#define DS1302_D7 7
// --------------------------------------------------------
// Bit for reading (bit in address) // _DS1302_start
#define DS1302_READBIT DS1302_D0 // READBIT=1: read instruction //
// A helper function to setup the start condition.
// Bit for clock (0) or ram (1) area, //
// called R/C-bit (bit in address) // An 'init' function is not used.
#define DS1302_RC DS1302_D6 // But now the pinMode is set every time.
// That's not a big deal, and it's valid.
// Seconds Register // At startup, the pins of the Arduino are high impedance.
#define DS1302_CH DS1302_D7 // 1 = Clock Halt, 0 = start // Since the DS1302 has pull-down resistors,
// the signals are low (inactive) until the DS1302 is used.
// Hour Register void _DS1302_start( void)
#define DS1302_AM_PM DS1302_D5 // 0 = AM, 1 = PM {
#define DS1302_12_24 DS1302_D7 // 0 = 24 hour, 1 = 12 hour digitalWrite( DS1302_CE_PIN, LOW); // default, not enabled
pinMode( DS1302_CE_PIN, OUTPUT);
// Enable Register
#define DS1302_WP DS1302_D7 // 1 = Write Protect, 0 = enabled digitalWrite( DS1302_SCLK_PIN, LOW); // default, clock low
pinMode( DS1302_SCLK_PIN, OUTPUT);
// Trickle Register
#define DS1302_ROUT0 DS1302_D0 pinMode( DS1302_IO_PIN, OUTPUT);
#define DS1302_ROUT1 DS1302_D1
#define DS1302_DS0 DS1302_D2 digitalWrite( DS1302_CE_PIN, HIGH); // start the session
#define DS1302_DS1 DS1302_D2 delayMicroseconds( 4); // tCC = 4us
#define DS1302_TCS0 DS1302_D4 }
#define DS1302_TCS1 DS1302_D5
#define DS1302_TCS2 DS1302_D6
#define DS1302_TCS3 DS1302_D7 // --------------------------------------------------------
// _DS1302_stop
//
// Structure for the first 8 registers. // A helper function to finish the communication.
// These 8 bytes can be read at once with //
// the 'clock burst' command. void _DS1302_stop(void)
// Note that this structure contains an anonymous union. {
// It might cause a problem on other compilers. // Set CE low
typedef struct ds1302_struct digitalWrite( DS1302_CE_PIN, LOW);
{
uint8_t Seconds:4; // low decimal digit 0-9 delayMicroseconds( 4); // tCWH = 4us
uint8_t Seconds10:3; // high decimal digit 0-5 }
uint8_t CH:1; // CH = Clock Halt
uint8_t Minutes:4;
uint8_t Minutes10:3; // --------------------------------------------------------
uint8_t reserved1:1; // _DS1302_toggleread
union //
{ // A helper function for reading a byte with bit toggle
struct //
{ // This function assumes that the SCLK is still high.
uint8_t Hour:4; //
uint8_t Hour10:2; uint8_t _DS1302_toggleread( void)
uint8_t reserved2:1; {
uint8_t hour_12_24:1; // 0 for 24 hour format uint8_t i, data;
} h24;
struct data = 0;
{ for( i = 0; i <= 7; i++)
uint8_t Hour:4; {
uint8_t Hour10:1; // Issue a clock pulse for the next databit.
uint8_t AM_PM:1; // 0 for AM, 1 for PM // If the 'togglewrite' function was used before
uint8_t reserved2:1; // this function, the SCLK is already high.
uint8_t hour_12_24:1; // 1 for 12 hour format digitalWrite( DS1302_SCLK_PIN, HIGH);
} h12; delayMicroseconds( 1);
};
uint8_t Date:4; // Day of month, 1 = first day // Clock down, data is ready after some time.
uint8_t Date10:2; digitalWrite( DS1302_SCLK_PIN, LOW);
uint8_t reserved3:2; delayMicroseconds( 1); // tCL=1000ns, tCDD=800ns
uint8_t Month:4; // Month, 1 = January
uint8_t Month10:1; // read bit, and set it in place in 'data' variable
uint8_t reserved4:3; bitWrite( data, i, digitalRead( DS1302_IO_PIN));
uint8_t Day:3; // Day of week, 1 = first day (any day) }
uint8_t reserved5:5; return( data);
uint8_t Year:4; // Year, 0 = year 2000 }
uint8_t Year10:4;
uint8_t reserved6:7;
uint8_t WP:1; // WP = Write Protect // --------------------------------------------------------
}; // _DS1302_togglewrite
//
// A helper function for writing a byte with bit toggle
void setup() //
{ // The 'release' parameter is for a read after this write.
ds1302_struct rtc; // It will release the I/O-line and will keep the SCLK high.
//
lcd.begin(16,2); // LCDa hasieratu void _DS1302_togglewrite( uint8_t data, uint8_t release)
Serial.begin(9600); {
Serial.println(F("DS1302 Real Time Clock")); int i;
Serial.println(F("Version 2, March 2013"));
for( i = 0; i <= 7; i++)
{
// Start by clearing the Write Protect bit // set a bit of the data on the I/O-line
// Otherwise the clock data cannot be written digitalWrite( DS1302_IO_PIN, bitRead(data, i));
// The whole register is written, delayMicroseconds( 1); // tDC = 200ns
// but the WP-bit is the only bit in that register.
DS1302_write (DS1302_ENABLE, 0); // clock up, data is read by DS1302
digitalWrite( DS1302_SCLK_PIN, HIGH);
// Disable Trickle Charger. delayMicroseconds( 1); // tCH = 1000ns, tCDH = 800ns
DS1302_write (DS1302_TRICKLE, 0x00);
if( release && i == 7)
// Remove the next define, {
// after the right date and time are set. // If this write is followed by a read,
#define SET_DATE_TIME_JUST_ONCE // the I/O-line should be released after
#ifdef SET_DATE_TIME_JUST_ONCE // the last bit, before the clock line is made low.
// This is according the datasheet.
// Aldagai hauek bete itzazu behar den ordua eta datarekin: // I have seen other programs that don't release
int seconds, minutes, hours, dayofweek, dayofmonth, month, year; // the I/O-line at this moment,
// and that could cause a shortcut spike
// on the I/O-line.
// HEMEN ORDUA ETA DATA ZEHAZTUKO DIRA. ADIBIDEZ, 2014-10-26, 10:00:00, IGANDEA: ASTEKO 7. EGUNA. pinMode( DS1302_IO_PIN, INPUT);
// ORDUA ETA DATA ZAHAZTU:
seconds = 55; // For Arduino 1.0.3, removing the pull-up is no longer needed.
minutes = 59; // Setting the pin as 'INPUT' will already remove the pull-up.
hours = 23; // digitalWrite (DS1302_IO, LOW); // remove any pull-up
dayofweek = 7; // asteko eguna 1...7 }
dayofmonth = 26; // Hileko eguna, 1...31 else
month = 10; // Hila 1...12 {
year = 2014; // Urtea digitalWrite( DS1302_SCLK_PIN, LOW);
delayMicroseconds( 1); // tCL=1000ns, tCDD=800ns
// Orduaren eta dataren arabera piztuko diren irteerak deklaratu: }
pinMode(LED13, OUTPUT); // pin digitala irteera gisa deklaratuko da }
digitalWrite (LED13, LOW); }
// Set a time and date

// This also clears the CH (Clock Halt) bit,
// to start the clock.
// Fill the structure with zeros to make

// any unused bits zero
memset ((char *) &rtc, 0, sizeof(rtc));
rtc.Seconds = bin2bcd_l( seconds);
rtc.Seconds10 = bin2bcd_h( seconds);
rtc.CH = 0; // 1 for Clock Halt, 0 to run;
rtc.Minutes = bin2bcd_l( minutes);
rtc.Minutes10 = bin2bcd_h( minutes);
// To use the 12 hour format,
// use it like these four lines:
// rtc.h12.Hour = bin2bcd_l( hours);
// rtc.h12.Hour10 = bin2bcd_h( hours);
// rtc.h12.AM_PM = 0; // AM = 0
// rtc.h12.hour_12_24 = 1; // 1 for 24 hour format
rtc.h24.Hour = bin2bcd_l( hours);
rtc.h24.Hour10 = bin2bcd_h( hours);
rtc.h24.hour_12_24 = 0; // 0 for 24 hour format
rtc.Date = bin2bcd_l( dayofmonth);
rtc.Date10 = bin2bcd_h( dayofmonth);
rtc.Month = bin2bcd_l( month);
111
rtc.Month10 = bin2bcd_h( month);
rtc.Day = dayofweek;
rtc.Year = bin2bcd_l( year - 2000);
rtc.Year10 = bin2bcd_h( year - 2000);
rtc.WP = 0;
// Write all clock data at once (burst mode).

DS1302_clock_burst_write( (uint8_t *) &rtc);
#endif
112
7. BLOKEA:
INFRAGORRIAK
113
7. BLOKEA: INFRAGORRIAK
Helburua
Oraingo blokean, helburua da urrutiko aginte batekin irteera digitalak

kontrolatzea. Adibidez, pertsiana bat ireki edo itxi, argi bat piztu edo amatatu,
edo, bururatzen zaigun zernahi kontrola.
- Arduinoari infragorrien sentsore bat konektatzen

- Kodea jaitsi eta moldatzen
- Urrutiko aginte baten seinalea eskuratzen
- Eskuratutako seinaleen arabera irteerak pizten
7P1: IG. URRUTIKO AGINTEEN BOTOIEN KODEA ESKURATU

7P2: IG. URRUTIKO AGINTE BAT TESTEATU
7P3: IG. IRTEERAK AKTIBATU URRUTIKO AGINTE BATEKIN
114
PRAKTIKAK
7P1: IG. URRUTIKO AGINTEEN BOTOIEN KODEA ESKURATU
1. Helburuak
Lehenengo praktikaren helburua urrutiko aginte baten botoien seinaleak

hartzea da. Jasoko den seinaleari kodea deituko diogu. Botoiaren kode
horrekin, irteera digital bat piztu daiteke, adibidez.
Kodea arduinoan exekutatzen denean, ordua eta data egokituko dira eta serie-
monitorean bistaratuko dira.
2. Prozedura
Kodigoa esteka honetatik jaitsi dezakezu:
http://www.righto.com/2009/08/multi-protocol-infrared-remote-library.html
Liburutegi hau instalatu behar da:
#include <IRremote.h> https://www.pjrc.com/teensy/td_libs_IRremote.html
Zirkuitu elektrikoa muntatu.
Kodea arduinoan kargatu eta serie-monitorea ireki.
Urrutiko agintearen botoiak sakatu. Horiek serie-monitorean bistaratuko dira.
Serie-monitorean ikusten dira sakatutako botoien kodeak:
115
116
3. Materiala

- VS1838B infragorrien hartzailea
- Urrutiko aginte bat (etxeko edozeinek balio du: telebistarenak adibidez)
5. Kodea
// Kode honek urrutiko aginteen botoien kodea irakurtzen du eta serie-
monitorean bistaratzen du.
#include <IRremote.h>
int igPIN = 2;
IRrecv irrecv(igPIN);
decode_results eskuratutakoKodea;
void setup()
{
Serial.begin(9600);
irrecv.enableIRIn(); // Hartzailea hasieratu
Serial.println("Kaixo!! Sakatu urrutiko agintearen botoia eta
helbidearen kodea esango dizut!");
}
void loop() {
if (irrecv.decode(&eskuratutakoKodea)) {
Serial.print("Sakatutako botoiaren kodea: ");
Serial.print(eskuratutakoKodea.value, HEX);
Serial.println(" da");
irrecv.resume(); // Hurrengo balioa hartu
}
}
117
6. Emaitzak
Botoien helbideen zerrenda bat egingo da, eta bakoitzaren kodea jarriko da.
Urrutiko agintearen botoiak ezkerretik eskuinera eta goitik behera doaz:
URRUTIKO AGINTEA BOTOIA HELBIDEA
1 FFA25D
2 FF629D
3 FFE21D
4 FF22DD
5 FF02FD
6 FFC23D
7 FFE01F
8 FFA857
9 FF906F
10 FF6897
11 FF9867
12 FFB04F
13 FF30CF
14 FF18E7
15 FF7A85
16 FF10EF
17 FF38C7
18 FF5AA5
19 FF42BD
20 FF4AB5
21 FF52AD
118
7P2: IG. URRUTIKO AGINTE BAT TESTEATU
6. Helburuak
Helburua da urrutiko aginte bat testeatzen ikastea. Testeatzea garrantzitsua da,

eta ezer aktibatu baino lehenagoko pausoa da. Sistema egiaztatu denean, 3.
praktikan egin dugu, irteera digitalak aktibatuko ditugu.
7. Prozedura
Aurreko praktikan eskuratu diren botoien kodeekin software berri bat egingo da.
Software horrekin, urrutiko agintea testeatuko dugu: urrutiko agintearen botoi
bat sakatzen denean, botoi horren esanahia bistaratuko da serie-monitorean,
eta urrutiko agintea ondo dagoen jakingo dugu.
Aurreko praktikako materiala eta muntaia elektrikoa berrerabiliko dira.

Softwareari dagokionez, kode berri bat sortuko da.
119
120
8. Kodea
// Urrutiko aginte baten seinale infragorriak jasoko dira.
// Urrutiko aginte horren botoien esanahia serie-monitorean bistaratuko da.
// Horrekin, egindako kode eta botoien esleipena zuzena dela egiaztatuko da
#include "IRremote.h"
int igPIN = 2; // Seinale infragorriak arduinoaren 2. pinetik jasoko dira
IRrecv irrecv(igPIN); // 'igPIN'etik kodea jasoko da

decode_results eskuratutakoKodea; // 'eskuratutakoKodea'n kodea Hex.
formatuan deskodetuko da
void setup()
{
Serial.begin(9600);
Serial.println("Infragorriak testeatzen!");
Serial.println("Sakatu urrutiko agintearen botoiak eta ziurtatu egokiak
direla!");
}
void loop()
{
if (irrecv.decode(&eskuratutakoKodea)) // Jaso al da seinale infragorririk?
{
translateIR(); // Sakatu den botoiaren esanahia serie-monitorean
inprimatu
}
}
void translateIR() // Jasotako Infragorriak kodearen arabera, agindua bete

{
switch(eskuratutakoKodea.value)
{
case 0xFFA25D: Serial.println(" 1 POWER "); break;
case 0xFF629D: Serial.println(" 2 MODE "); break;
case 0xFFE21D: Serial.println(" 3 IXILDU "); break;
case 0xFF22DD: Serial.println(" 4 PLAY "); break;
case 0xFF02FD: Serial.println(" 5 ATZERA "); break;
case 0xFFC23D: Serial.println(" 6 AURRERA "); break;
case 0xFFE01F: Serial.println(" 7 EQ "); break;
case 0xFFA857: Serial.println(" 8 VOL- "); break;
case 0xFF906F: Serial.println(" 9 VOL+ "); break;
case 0xFF6897: Serial.println(" 10 0 "); break;
case 0xFF9867: Serial.println(" 11 SS "); break;
case 0xFFB04F: Serial.println(" 12 U/SD "); break;
case 0xFF30CF: Serial.println(" 13 1 "); break;
case 0xFF18E7: Serial.println(" 14 2 "); break;
case 0xFF7A85: Serial.println(" 15 3 "); break;
case 0xFF10EF: Serial.println(" 16 4 "); break;
case 0xFF38C7: Serial.println(" 17 5 "); break;
case 0xFF5AA5: Serial.println(" 18 6 "); break;
case 0xFF42BD: Serial.println(" 19 7 "); break;
case 0xFF4AB5: Serial.println(" 20 8 "); break;
case 0xFF52AD: Serial.println(" 21 9 "); break;
default: Serial.println(" 22 other button ");
}
delay(500);
}
121
7P3: IG. IRTEERAK AKTIBATU URRUTIKO AGINTE BATEKIN
1. Helburuak
Orain badakigunez urrutiko aginteak ondo erantzuten duela, aurreko praktika

berrerabiliko da irteerak aktibatzeko. Programa berri horrek, urrutiko agintearen
botoiak sakatzen direnean, 3 irteera digitalak kontrolatuko ditu. 6 botoi erabiliko
dira: 3, LEDak pizteko, eta beste 3, LEDak amatatzeko.
2. Prozedura
Aginduak betetzeko, 1, 2 eta 3 botoiek LEDak piztuko dituzte, eta 4, 5 eta 6

botoiek LEDak amatatuko dituzte. Urrutiko agintean aukeratu diren botoiak eta
kodeak taula honetan daude eskuragarri:
BOTOI ZENBAKI KODEA

A A
Piztu L1 1 13 FF30CF
Piztu L2 2 14 FF18E7
Piztu L3 3 15 FF7A85
Amatatu 4 16 FF10EF
L1
Amatatu 5 17 FF38C7
L2
Amatatu 6 18 FF5AA5
L3
Aurreko praktikako materiala eta muntaia elektrikoa berrerabiliko dira.

Softwareari dagokionez, aurreko praktikako kodea berrerabiliko da.
122
3. Kodea
// Urrutiko aginte baten seinale infragorriak jasoko dira
// Urrutiko aginte horren botoien esanahia serie-monitorean bistaratuko da
// Horrekin, egindako kode eta botoien esleipena zuzena dela egiaztatuko da
#include "IRremote.h"
int igPIN = 2; // Seinale infragorriak arduinoaren 2. pinetik jasoko dira
IRrecv irrecv(igPIN); // 'igPIN'etik kodea jasoko da

decode_results eskuratutakoKodea; // 'eskuratutakoKodea'n kodea Hex.
int L1 = 3; // 3. pinaren izena

void setup()
{
Serial.begin(9600);
Serial.println("Ifragorriak testeatzen!");
Serial.println("Sakatu urrutiko agintearen botoiak eta ziurtatu egokiak
direla!");
pinMode(L1, OUTPUT); // pin digitala sarrera gisa deklaratuko da

}
void loop()
{
if (irrecv.decode(&eskuratutakoKodea)) // Jaso al da InfraGorri seinalerik?
{
translateIR();// Sakatu den botoiaren esanahia serie-monitoretik inprimatu
}
}
void translateIR() // Jasotako infragorriak kodearen arabera, agindua bete

{
{
case 0xFF30CF: digitalWrite(L1, HIGH); Serial.println(" L1 piztu");

break; // Botoia 1 sakatuta
case 0xFF18E7: digitalWrite(L2, HIGH); Serial.println(" L2 piztu");
case 0xFF7A85: digitalWrite(L3, HIGH); Serial.println(" L3 piztu");
case 0xFF10EF: digitalWrite(L1, LOW); Serial.println(" L1 amatatu");
case 0xFF38C7: digitalWrite(L2, LOW); Serial.println(" L2 amatatu");
case 0xFF5AA5: digitalWrite(L3, LOW); Serial.println(" L3 amatatu");
default: Serial.println("Botoi hau ez dago erabilgarri"); // Botoi
okerra sakatuta
}
delay(500);
}
123
8. BLOKEA:
ETHERNET
124
8. BLOKEA: ETHERNET
Helburua
Arduinoa Interneten bidez kontrolatzea da helburua. ETHERNETen bidez

kontrolatuko da sare lokalean instalatu dugun arduinoa (LAN sarea).
Bi, bereziki, izango dira egitekoak:
Lehenengoa, arduinoak datuak bidaliko ditu web-orrialde batera: Datu horiek,

adibidez, tenperatura, hezetasuna, edo sarrera/irteera digitalen egoera izango
dira.
Bigarrena, Arduinoari sarearen bidez emango zaizkio aginduak: Irteera digital

bat piztea edo amatatzea, edo irteera analogiko baten balioa aldatzea,
adibidez.
- Arduinoari ETHERNET SHIELD bat konektatzen

- Konexioak egiten eta IP helbide bat lortzen eta konfiguratzen
- Datuak bidaltzen arduinotik web-orrialde batera
- Arduinoari aginduak ematen LAN sarearen bidez
8P1 LAN. SARRERA ANALOGIKOEN BALIOAK ONLINE ERAKUTSI

8P2 LAN. LED BAT PIZTU WEB ORRIALDE BATETIK
125
KONEXIOAK
ETHERNET SHIELD plaka arduinoaren gainean muntatuko da.
Arduinoak ETHERNET SHIELD plakarekin komunikatzeko 10, 11, 12 eta 13

pin digitalak erabiltzen ditu. Pin horiek, SHIELD hau erabilita, ezin daitezke
Sarrera/Irteera digital moduan erabili.
Shield honek reset botoia bat dauka, eta plaka biak aldi berean erreseteatzeko
balio du: Bai arduino-plaka eta bai ETHERNET SHIELD plaka.
Konektatu ezazu ETHERNET plaka erruter batera (edo ordenagailura, praktikak

etxean egiten badituzu) ethernet kable estandar batekin (CAT5 edo
CAT6 ezaugarriko RJ45 konektorearekin).
Plakari, libre dagoen IP helbide bat esleitu behar zaio. MAC helbidea gailu
batek izango duen helbidea da. Ez erabili MAC helbide bera plaka bat baino
gehiago konektatzen baduzu.
ETHERNET SHIELD plakak hainbat LED ditu informazioa emateko:
- PWR: plaka elikatuta dagoela adierazten du.
- LINK: sarean dagoela adierazten du, eta datuak bidaltzen edo jasotzen
direnean dir-dir jartzen da.
- FULLD: full duplex-ek sare-konexioa dagoela adierazten du.
- 100M: 100 Mb/s-ko sare konexioa dago.
- RX: datuak jasotzean, keinuka jartzen da, bestela itzalita dago.
- TX: datuak bidaltzean, keinuka jartzen da, bestela itzalita dago.
126
- COLL: sarean talkak sortzen direnean, keinuka jartzen da, bestela itzalita
dago.
IP HELBIDEA ESLEITZEA: ARDUINOA ERRUTERRERA KONEKTATU
Eruterraren IPa atzeko partean dator: 192.168.0.1. Horrez gain, erabiltzaile eta
pasahitz bat datoz erruterrean konfigurazioak egin ahal izateko.
Erruterraren helbidea jakiteko, badago beste era bat ere: Ordenagailuak

erabiltzen duen IP helbidea lortuko dugu, eta horrekin, erruterraren helbidea
zein den jakingo dugu. Pauso hauek jarraitu behar dituzu:
CMD exekutatu kontsola agertu dadin. Kontsolan “ipconfig” komandoa

exekutatu, eta leiho hau agertuko da:
Nire ordenagailua 192.168.0.194 helbidean dago konektatuta. Horrek esan nahi

du 192.168.0.XXX barrutiaren lehenengo helbidea, erruterrarena dela:
192.168.0.1, erruterraren atzeko pegatinan jartzen duen moduan.
Libre dagoen IP helbide bat esleitu beharko diogu arduinoari (guk geuk),
192.168.0.XXX barrutikoa; adibidez, 192.168.0.200. Helbide hori ea libre
dagoen jakin behar da erabili baino lehen:
Windowseko kontsolan, ping 192.168.0.200 exekutatuko da. Erantzunik ez

badago, helbide hori libre dagoela esan nahi du. Hemen ez dago erantzunik,
beraz, 192.168.0.200 helbidea arduinoari esleituko diogu:
127
128
IP HELBIDEA LORTZEA: ARDUINOA ORDENAGAILURA KONEKTATU
Arduinoa erruterrera konektatu beharrean, aurreko atalean planteatu den

moduan, ordenagailuaren sare-portura konektatzea planteatzen da. Hori
interesgarria da, adibidez, erruterra etxeko beste puntan dagoenean.
Programa (sketch) batek guk nahi dugun moduan funtzionatzeko, Arduinoarekin

lan egin duzuenok jakingo duzuenez, behin eta berriro antzeko sketchak
kargatu beharko dira: beti egin behar zaie aldaketaren bat; bada, gauza bera
gertatuko da ETHERNET SHIELDekin lan egiten dugunean: programak guk
nahi dugun moduan funtzionatu arte aldaketak egin beharko zaizkio. Frogak
egiteko arduinoa ordenagailuko sarera konektatzen bada, nahi beste froga egin
daitezke konektatu eta deskonektatu barik.
Programa findu arte, arduinoa ordenagailura lotuta egingo dugu lan. Hori lortu
ostean, erruterrean jarriko dugu erosoagoa delako eta ez dugulako bueltaka ibili
behar. Gainera, konektoreak apurtu egin daitezke sarritan jarri eta kendu
ibiltzen bagara.
Zer IP helbide emango zaio arduinoari ordenagailuaren sarearekin lan

egin dezan?
Ikus dezagun zelan lortu IP helbide hori.
1. Arduinoa ordenagailura konektatu barik CMD exekutatuko dugu kontsola

agertu dadin. Kontsolan “ipconfig” komandoa exekutatuko dugu. Leiho
hau agertuko da:
129
2. Arduinoa ordenagailura konektatu eta CMD exekutatu kontsola agertu
dadin. Kontsolan “ipconfig” idatzi komandoa exekutatzeko. Leiho hau
agertuko da:
Aurreko leiho biak aztertzen baditugu, ikusiko dugu, bigarren leihoan,

ETHERNET konexioan, helbide berri bat agertu dela: 169.254.231.251
helbidea.
Arduinoak, ordenagailuarekin komunikatzeko, barruti horretako IP helbide bat

izan behar du. Barruti berri horretan, 169.254.231.XXX barrutian, edozein
helbide har dezakegu gure arduinoak erabiltzeko, 169.254.231.251 helbidea
izan ezik; izan ere, dagoeneko hartuta dago helbide hori. Adibidez,
169.254.231.252. Badaezpada, helbidea libre dagoen jakin behar dugu.
Lehenengo, 169.254.231.251 helbidea hartuta dagoela ziurtatuko dugu:

Windowsen kontsolan ping 169.254.231.251 exekutatuko dugu. Erantzunik ez
badago, horrek helbide hori libre dagoela esan nahi du. Hemen erantzuna
dago: zer edo zer dago konektatuta. Horregatik esan dugu arestian helbide hori
ezin daitekeela erabili.
130
Goazen, orduan, 169.254.231.252 helbidea libre dagoen aztertzera.
Windowsen kontsolan ping 169.254.231.252 exekutatuko dugu. Erantzunik ez
badago, helbide hori libre dagoela esan nahi du. Hemen ez dago erantzunik,
beraz, 169.254.231.252 helbide hori arduinoari emango diogu:
Geroago, atal honetako lehenengo praktika egiteko arduinoa 169.254.231.252

helbidearekin kargatzen denean, Windowsen kontsolan ping 169.254.231.252
exekutatzen baduzu, IP hori erabilita dagoela ikusiko duzu:
Laburbilduta:
Erruterraren helbidea:
192.168.0.1
Arduinoa erruterrera konektatzen badugu, erabiliko den helbidea:

192.168.0.200
Arduinoa ordenagailura konektatzen badugu, erabiliko den helbidea:

169.254.231.252
131
8P1 LAN. SARRERA ANALOGIKOEN BALIOAK ONLINE
ERAKUTSI
1. Helburuak
Arduinoaren 6 sarrera analogikoak irakurriko ditugu. Irakurketa horiek online

bistaratuko dira web-orrialde batean. Serie-monitorearekin eta displayarekin
egiten zen moduan.
2. Prozedura
Arduino Ethernet Shield plaka bat konektatuko zaio arduinoari. Elikadura

jarriko zaio, eta sareko kablea ordenagailutik edo erruterretik arduinora
(Ethernet kable estandar batekin, RJ45).
Arduinoak, sarean ikusgai egon dadin, programa behar du eta IP bat; beraz,
kargatu egingo diogu programa, eta IPa ere programa horren bidez esleituko
diogu.
3. Materiala

- ARDUINO ETHERNET SHIELD bat
132
Gogora ezazu 10, 11, 12 eta 13 pinak ezin daitezkeela erabili, Ethernet
Shieldak erabiliko dituela.
5. Oharrak
Kodea Adibideak / Ethernet / WebZerbitzariaetik aterako da.
133
ZEIN IP HELBIDE ERABILI
Erabiliko den IPa eskura izan behar da. Kasu honetan, 192.168.0.200 da
erruterrera konektatzen bada arduinoa; eta 169.254.231.252, ordenagailura
konektatzen bada arduinoa.
Gure kasu honetan –dagoeneko programa findu dugu ordenailuan– erruterrera

konektatuko dugu:
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,0,200);
134
6. Kodea
/*
Web Zerbitzaria: Sarrera analogikoen balioak, A0-A5
web-orrialde baten bistaratu
*/
#include <SPI.h>
#include <Ethernet.h>
// Hemen IP helbidea jarriko da
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(192,168,0,200); //192.168.0.200
EthernetZerbitzaria zerbitzaria(80); // Ethernet zerbitzariaren
liburutegia
void setup()
{
Serial.begin(9600);
while (!Serial) {
; // Itxaron serie-portuarekin konektatzeko. Leonardo plakarako
bakarrik
}
// Hasieratu Ethernet konexioa eta zerbitzaria:

Ethernet.begin(mac, ip);
zerbitzaria.begin();
Serial.print("Zerbitzaria hemen dago: ");
Serial.println(Ethernet.localIP());
}
void loop()
{
// Etortzen diren bezeroak entzun
EthernetBezeroa bezeroa = zerbitzaria.available();
if (bezeroa) {
Serial.println("new bezeroa");
// http eskaria linea zuri batekin bukatuko da
boolean currentLineIsBlank = true;
while (bezeroa.connected()) {
if (bezeroa.available()) {
char c = bezeroa.read();
Serial.write(c);
if (c == '\n' && currentLineIsBlank) {
// bidali mezu estandar bat
bezeroa.println("HTTP/1.1 200 OK");
bezeroa.println("Content-Type: text/html");
bezeroa.println("Connection: close");
bezeroa.println("Refresh: 5"); // freskatzea 5 segundoero
bezeroa.println();
bezeroa.println("<!DOCTYPE HTML>");
bezeroa.println("<html>");
// inprimatu sarrera analogikoen balioa

for (int analogChannel = 0; analogChannel < 6;
analogChannel++) {
int sensorReading = analogRead(analogChannel);
bezeroa.print(" Sarrera Analogikoa ");

bezeroa.print(analogChannel);
bezeroa.print(" ");
135
bezeroa.print(sensorReading);
bezeroa.print(" da. ");
bezeroa.println("<br />");
}
bezeroa.println("</html>");
break;
}
if (c == '\n') {
currentLineIsBlank = true;
}
else if (c != '\r') {
currentLineIsBlank = false;
}
}
}
delay(1); // web-orrialdeari denbora emango zaio datua jaso dezan.
bezeroa.stop(); // Konexioa itxi
Serial.println("bezeroa disonnected");
}
}
Nabigatzailean 192.168.0.200 helbidea idazten badugu, hauxe ikusi behar da.
Aztertu egindako konexioa, ea balio analogikoak bat datozen egindako

konexioekin. Hemen, adibidez, 5. sarrera analogikoa GND pinera konektatu da.
136
8P2 LAN. LED BAT PIZTU WEB-ORRIALDE BATETIK
1. Helburuak
Irteera digital bat piztea da helburua. Oraingoan, LAN sare batetik eta HTML
hizkuntza erabilita, oinarrizko bi botoidun web-orrialde bat sortuko da.
2. Prozedura

jarriko zaio arduinoari, eta ordenagailutik edo erruterretik arduinora sareko
kablea (Ethernet kable estandar batekin, RJ45).
Arduinoak, sarean ikusgai egon dadin, programa behar du eta IP bat; beraz,
kargatu egingo diogu programa, eta IPa ere programa horren bidez esleituko
diogu.
3. Materiala

Gogora ezazu 10, 11, 12 eta 13 pinak ezin daitezkeela erabili,. Ethernet
Shieldak erabiliko dituela.
137
5. Kodea
/*
Irteera digital bat ordenagailu baten bitarrtez piztu eta amatatuko da
.
Web-orrialde txiki bat sortuko da bi botoirekin HTML formatuan
*/
#include <SPI.h>
byte mac[]={0xDE,0xAD,0xBE,0xEF,0xFE,0xED}; //MAC
IPAddress ip(192,168,0,200); //IP 192.168.0.200
EthernetZerbitzaria zerbitzaria(80); // Ethernet zerbitzariaren
liburutegia
int PIN_LED=8;
String readString=String(30);
String state=String(3);
void setup() {
Ethernet.begin(mac, ip); // Hasieratu Ethernet konexioa eta
zerbitzariaa
pinMode(PIN_LED,OUTPUT);
digitalWrite(PIN_LED,LOW);
state="ITZALITA";
}
void loop() {
EthernetBezeroa bezeroa= zerbitzaria.available();
if(bezeroa) {
boolean lerrozuria=true;
while(bezeroa.connected()) {
if(bezeroa.available()) {
char c=bezeroa.read();
if(readString.length()<30) {
readString.concat(c);
}
if(c=='\n' && lerrozuria)
{
int LED = readString.indexOf("LED=");
if(readString.substring(LED,LED+5)=="LED=T") {
digitalWrite(PIN_LED,HIGH);
state="PIZTUTA"; }
else if (readString.substring(LED,LED+5)=="LED=F") {
digitalWrite(PIN_LED,LOW);
state="ITZALITA";
}
//Web-orrialdea sortu
bezeroa.println(); // Web-orrialdea HTML formatuan
bezeroa.println("<head>");
bezeroa.println("<title>LED bat piztu/itzali</title>");
bezeroa.println("</head>");
bezeroa.println("<body width=100% height=100%>");
bezeroa.println("<center>");
bezeroa.println("<h1>LED bat piztu/itzali</h1>");
138
bezeroa.print("<br><br>");
bezeroa.print("LEDaren egoera: ");
bezeroa.print(state);
bezeroa.print("<br><br><br><br>");
bezeroa.println("<input type=submit value=PIZTU
style=width:200px;height:75px onClick=location.href='./?LED=T\'>");
bezeroa.println("<input type=submit value=ITZALI
style=width:200px;height:75px onClick=location.href='./?LED=F\'>");
bezeroa.println("</center>");
bezeroa.println("</body>");
bezeroa.stop();
// bezeroarekin konexioa bukatu
readString="";
}
}
}
}
}
Nabigatzailean 192.168.0.200 helbidea idazten badugu, hauxe ikusi behar da.
Konprobatu ezazu, led batekin edo polimetroarekin, ea 8. pina piztu edo itzali
egiten den.
139
9. BLOKEA:
INTERNET
140
9. BLOKEA: INTERNET
Helburua
Helburua da arduinoa Interneten bidez kontrolatzea. Interes handiko praktika da

hau, gure arduinoa kontrolatu ahal dugulako munduko edozein puntatatik
Internetera konexiorik badugu. Smartphone batetik, adibidez.
Aurreko praktikan bezala, bereziki bi izango dira egitekoak:
Lehenengoa, arduinoak datuak bidaliko ditu web-orrialde batera: Datu horiek,

tenperatura, hezetasuna, edo sarrera/irteera digitalen egoera izan daitezke,
adibidez.
Bigarrena, arduinoari aginduak emango dizkiogu sarearen bidez: Irteera digital

bat piztea edo amatatzea eta irteera analogiko baten balioa aldatu, adibidez.

- IP helbideei buruzko teoria apur bat eta erruterra konfiguratzen
- Datuak bidaltzen arduinotik web-orrialde batera
- Arduinoari aginduak ematen INTERNET sarearen bidez
9P1 INTERNET. SARRERA ANALOGIKOEN BALIOAK ONLINE ERAKUTSI

9P2 INTERNET. LED BAT PIZTU WEB-ORRIALDE BATETIK
141
IP HELBIDEAK: TEORIA APUR BAT
IP helbide publikoa
Internetera konektatzeko IP helbide publiko bat behar da. Adibidez,

web-guneak ostatatzen dituzten zerbitzariek –Google–, etxeko erruterrak edo
modemak Internetera konektatzeko erabiltzen duten helbidea da.
IP publikoak bakarrak dira. Ezin daitezke errepikatu. Helbide hori gure erruterra
Interneteko web-zerbitzari batekin konektatzeko erabiltzen den helbidea da.
Tresna honen bidez zure IP helbidea jakin dezakezu: http://eu.1myip.com/
Nire kasuan, 37.135.106.36 IP helbide publikoa daukat esleituta. Helbide horren

bidez, erruterrean konektatuta dauden gailuak Internetera konektatu ahal
izango dira.
IP helbide pribatua
Etxeko gailuak –ordenagailu bi, inpresora bat eta eskaner bat, adibidez–
beren artean IP helbide pribatuekin komunikatzen dira. IP helbide horiek
berdinak izan daitezke beste hainbat sare pribatutan. Sare pribatu horietan IP
helbide berak izateak ez du konfliktorik eragingo, sare horiek Internetetik
isolaturik baitaude.
Internetera ateratzeko, bitarteko bat behar da: IP publikoa eta bide jakin
bat: IP pribatua eta irekitako portu bat.
NAT (Network Address Translation)
Sare pribatu bat Internetera (edo beste sare batera) konektatzeko,

bitarteko bat behar da: NATa. Erruterrak NATari egiten dio dei, eta NATak
bitartekari edo itzultzaile gisa egingo du lan.
142
IP FINKOAK ETA DINAMIKOAK
Makina batek, sarera konektatzean, beti IP helbide bera erabiltzen badu, esaten
da IP Finkoa duela. Honen adibide, Interneteko web zerbitzariak ditugu.
IP Dinamikoa esaten da, aldiz, makina berak sarera lotzeko IP helbide

desberdinak erabiltzen dituenean. Esate baterako, Interneteko zerbitzu-
hornitzaileek (ISP) beren bezeroei IP dinamikoak esleitzen dizkiete. Interneteko
hornitzaileek IP helbideak baino bezero gehiago dituzte eta horren ondorioz
saio bakoitzeko IP dinamikoak (desberdinak) esleitzen dizkiete, denak aldi
berean konektatzea nekez gertatzen baita.
DNS eta DHCP
DNS-a: Domain Name Servers (DNS) izeneko zerbitzarien egitekoa IP

zenbakiak hitzetara itzultzea da. Horri eskerrak, orain izen bat gogoratu behar
da helbideari dagokion zenbaki luzearen lekuan. Horrela, errazagoa da
www.domeinua.com gogoratzea 192.168.1.1 baino; edo
emaila@domeinua.com izatea helbide bat, emaila@192.168.1.1 izan
beharrean.
DHCP-a: Internet hornitzaileek IP dinamikoak esleitzen dizkiete beren bezeroei.

Helbideak automatikoki esleitzen dira. Gailu bat Internetera konektatzen
denean, DHCP-k IP helbide bat esleitzen dio gailu horri. Gailua Internetetik
deskonektatzen denean, DHCP-k liberatu egiten du helbide hori, eta libre
geratzen da beste gailu batek erabiltzeko.
Horrek esan nahi du gure IP publikoa aldatu egin daitekeela. Orduan,

arduino bat Internetera konektatu nahi badugu, zer egin daiteke IP helbide bera
mantentzeko? Bi aukera daude:
- IP finko bat alokatzea eta zerbitzu horren truke behar den tarifa ordaindu.
- IP publikoa izen baten azpian gordetzea, “arduinoaSarean.ddns.net”,

adibidez. IP dinamikoa aldatzen denean, IP berria automatikoki gordeko
da izenaren azpian.
143
IZEN BAT LORTU IP DINAMIKOARENTZAT
Arduinoari, Internetera konektatzeko, IP helbide bat eman behar diogu.

Demagun, 37.135.106.36 IP helbidea publikoa duela. IP helbide hori aldatzen
bada, DHCP-k egiten duen moduan, arduinoa ez da Internetera konektatuta
egongo.
Hori ekiditeko, IP helbideari izen bat emango zaio,

“arduinoaSarean.ddns.net”, adibidez. Hasierako 37.135.106.36 IP helbidea
uneren batean aldatzen bada, IP berri hori “arduinoaSarean.ddns.net”
izenaren azpian gordeko da.
Arduinoari Internetera konektatzeko emango diogun IP helbidea ez da

37.135.106.36 helbidea izango, “arduinoaSarean.ddns.net” baizik. Horrela, IP
dinamikoa aldatzen bada, arduinoak ez du helbidea galduko.
Domeinu bat lortzeko zerbitzua dohainik da oinarrizko bertsioan. Hemen lortu

daiteke domeinu bat, erabiltzaile eta pasahitzarekin:
https://www.noip.com/sign-up
ERABILIKO DITUGUN DATUEN LABURPENA
Alde batetik, aurreko praktikan IP helbide pribatuak lortu ditugu:
Erruterraren helbidea: 192.168.0.1

Arduinoa erruterrera konektatzeko helbidea: 192.168.0.200
Beste aldetik, orain, arduinoa Internetera konektatzeko IP helbide publikoa
lortu dugu, 37.135.106.36, eta domeinua, arduinoaSarean.ddns.net.
Domeinuaren erabiltzailea eta pasahitza apuntatuko ditugu, erruterraren
konfigurazioa egiteko eskatuko dizkigutelako gero.
144
ROUTERRA KONFIGURATU
1. pausoa: Errutera konfiguratzeko orrian sartu
Nabigatzailetik zure erruterra konfiguratzeko orrian sartuko gara. Nirea hau da:
http://192.168.0.1/. Erruterraren erabiltzailea eta pasahitza eskatuko dizkigu.
Sartu itzazu eta has gaitezen konfigurazioa egiten:
2. pausoa: Errutera konfiguratzeko menu nagusian sartu
Merkatuan, erruter modelo anitz dago. Bakoitzak bere konfigurazio menua du;
baina ez arduratu, hori telebista konfiguratzea bezain erraza baita. Azken
finean, telebista eta erruter gehienek aukera antzerakoak dituzte. Hurrengo
irudian agertzen da telefonia-etxe baten erruterraren menu nagusia. Erruter
jartzen duen tokian klikatuz gero, konfiguratzen has gaitezke. Ezer egin baino
lehen, LAN atalean, DHCP gaituko dugu:
145
3. pausoa: Erruterraren NAT aukera konfiguratu:
NAT atalera jo eta arduinoaren IP helbidea eta portua zehaztuko ditugu.

Arduinoari sare pribatuan emango zaion helbidea 192.168.0.200 da (zuk zeurea
sartu).
Esan dugunez, sare pribatu bat Internetera (edo beste sare batera)
konektatzeko, bitarteko bat behar dugu: NATa. Erruterrak NATari egiten dio dei,
eta NATak bitartekari edo itzultzaile gisa egingo du lan.
Erruterrean, 100. portua irekiko dugu. Hortik eta ez beste portu batetik izango
dugu arduinoa eskuragarri Internet bidez. Urrutitik konektatzean gure
erruterrera 100. portutik sartzen bagara, NAT-ak gure eskaria arduinoaren IP
pribatura bideratuko du, gure kasuan 192.168.0.200.
Portua aukeratzean, printzipioz, 100etik gertu dagoen portua har dezakegu.

Baina libre dagoen beste edozein ere har daiteke. Erabilita dagoen portu bat
erabiltzen saiatzen bagara, 80. portua adibidez, programak esango digu
erreserbatuta dagoela:
146
4. pausoa: Erruterraren DDNS aukera konfiguratu:
DDNS atalera joko dugu eta gure IP dinamikoari domeinua esleituko diogu.
Gure IP publikoari (dinamikoa denari) esleitu diogun domeinua zein den

adieraziko diogu erruterrari: arduinoaSarean.ddns.net (zuk zeurea sartu). Ez
ahaztu erabiltzailea eta pasahitza jartzea:
147
5. pausoa: Erruterra berrabiarazi
Erruterraren konfigurazio osoa egin ondoren, komeni da erruterra

BERRABIARAZTEA.
Orain arte egindako pausoak erruterra konfiguratzeko izan dira. Datozen
pausoak, instalazioa egiteko eta kontroladorea martxan uzteko dira:
6. pausoa: Arduinoari helbideak eman eta programa kargatu

Arduinoari helbideak emango dizkiot (badakizu: Zuk zeureak jarri behar dituzu).
Ostera, mac helbidea eta subnet helbidea erabili hemen agertzen direnak:
// Hemen IP helbidea idatziko da
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; // mac
byte ip[] = { 192, 168, 0, 200 }; // IP lokala 192.168.0.200
byte gateway[] = { 192, 168, 0, 1 }; // erruterraren IP
helbidea
byte subnet[] = { 255, 255, 255, 0 };
EthernetServer zerbitzaria(100); //erabili nahi dugun portua
Arduinoari programa kargatu behar zaio.
7. pausoa: Arduinoa erruterrean konektatu
Arduinoa erruterrean libre dagoen konektore batean konektatu behar da:
8. Pausoa: TESTEATU
148
Arduinoari web-nabigatzaile batetik deitzen badiogu, portua ere adierazi behar
dugu: Bestela, helbidea ez da osorik egongo. Bi era daude arduinoa Interneten
bidez aurkitzeko:
Beraren IP publikoarekin + portua (100): http://37.135.106.36/:100/
edo hobeto, beraren domeinuarekin + portua (100):
http://arduinoaSarean.ddns.net/:100/
KONTUZ!! Arduinoa IP publiko batean konektatuta

dago. Ezin daiteke web-orrialdea zabaldu IP publiko
beretik. Ezin daiteke zure erruterrera konektatuta
dagoen ordenagailurik, smartphonik edo tabletik
erabili.
Arduinoa Internetera konektatuta dagoen edo ez jakiteko:
- Beste IP publiko bat erabili, adibidez, smartphone batetik (ez erabili zure
erruterraren WIFI-a).
- Lagun bati LINK-a bidali eta berak zabaldu dezala.
149
9P1 LAN. SARRERA ANALOGIKOEN BALIOAK ONLINE
ERAKUTSI
1. Helburuak
Arduinoak dituen 6 sarrera analogikoak irakurriko dira. Irakurketa horiek online

bistaratuko dira, web-orrialde batean. Serie-monitorearekin edo displayarekin
egiten zen moduan.
2. Prozedura
Arduino Ethernet Shield plaka bat konektatuko diogu arduinoari. Elikadura eta
sareko kablea jarriko dizkiogu: erruterretik arduinora (RJ45 ethernet kable
estandar batekin).
Arduinoari, sarean ikusgai egoteko, behar duen programa kargatuko zaio. Eta
IP helbidea esleituko zaio.
3. Materiala

Gogora ezazu 10, 11, 12 eta 13 pinak ezin daitezkeela erabili, Ethernet
Shieldak erabiliko baititu.
150
5. Oharrak
Kodea Adibideak / Ethernet / WebServeretik aterako da. Aldaketak egin zaizkio IP

egokiak izan ditzan. Gainera, taula, kolorea eta LINK-a gehitu dira.
ZEIN IP HELBIDE ERABILI
Erabiliko den IPa eskura izan behar da. Kasu honetan, 192.168.0.200
da. Portua, 100. Programa honetan, MAC helbidea eta SUBNET ez dira
aldatuko. GATEWAY erruterraren IPa da:
// Hemen IP helbidea idatziko da
byte ip[] = { 192, 168, 0, 200 }; // IP lokala 192.168.0.200
byte gateway[] = { 192, 168, 0, 1 }; // Erruterraren IP
helbidea
byte subnet[] = { 255, 255, 255, 0 };
151
6. Kodea
/*
INTERNETEN bidez 6 sarrera analogikoen egoera kontsultatuko da.
HTML formatuan taula bat sortuko da
Web-orrialdearen kolorea berdea izango da
Web-orrialdeari LINK bat gehituko zaio.
*/
#include <SPI.h>
/*
IPAddress ip(169,254,231,252); //IP 169.254.231.252
EthernetServer zerbitzaria(80); // Ethernet zerbitzariaren liburutegia
*/
byte ip[] = { 192, 168, 0, 200 }; // IP lokala 192.168.0.200
byte gateway[] = { 192, 168, 0, 1 }; // Erruterraren IP helbidea
byte subnet[] = { 255, 255, 255, 0 };
void setup()
{
Serial.begin(9600);
while (!Serial) {
; // Itxaron portu-seriearekin konektatzeko. Leonardo plakarako
bakarrik
}
// Hasieratu Ethernet konexioa eta zerbitzaria:

Ethernet.begin(mac, ip);
//Ethernet.begin(mac, ip, gateway, subnet);
Serial.print("Zerbitzaria hemen dago: ");
Serial.println(Ethernet.localIP());
}
void loop()
{
// Etortzen diren bezeroak entzun
EthernetClient bezeroa = zerbitzaria.available();
if (bezeroa) {
Serial.println("new client");
// http eskaria lerro zuri batekin bukatuko da
boolean currentLineIsBlank = true;
Serial.write(c);
if (c == '\n' && currentLineIsBlank) {
//Web-orrialdea sortu
152
bezeroa.println("Connection: close");
bezeroa.println("Refresh: 5"); // freskatzea 5 segundoero
bezeroa.println(); // Web-orrialdea HTML formatuan
bezeroa.println("<!DOCTYPE HTML>");
bezeroa.println("<head>");
bezeroa.println("<title>SARRERA ANALOGIKOAK IRAKURRI</title>");
bezeroa.println("</head>");
bezeroa.println("<body>"); //cliente.println("<body width=100%
height=100%>");
bezeroa.println("<body bgcolor=#97FC95 height=100% width=100%>");
bezeroa.println("<p style=text-align: right;>PLAYGROUND <a
href=http://playground.arduino.cc/ >ARDUINO</a></p>");
bezeroa.print("<p> </p><table border=1 cellpadding=3

cellspacing=3 height=194 style=background-color: rgb(255, 255, 102);
border-collapse: collapse; border: 1px solid rgb(0, 0, 0); color:
rgb(0, 0, 0); width=293><tbody><tr><td style=text-align:
center;><strong>SARRERA ANALOGIKOAK</strong></td><td style=text-align:
center;><strong>EGOERA</strong></td></tr><tr>");
bezeroa.print("<td style=text-align: center;><strong>S.A.
0</strong></td><td style=text-align: right;>");
bezeroa.print(analogRead(0)); bezeroa.print("</td></tr><tr>");
5</strong></td><td style=text-align: center;>");
bezeroa.print(analogRead(5));
bezeroa.print("</td></tr></tbody></table>");
bezeroa.println("</body>");
bezeroa.stop();
}
if (c == '\n') {
currentLineIsBlank = true;
}
else if (c != '\r') {
currentLineIsBlank = false;
}
}
}
delay(1); // web-bilatzaileari denbora emango zaio datua jaso
dezan.
bezeroa.stop(); // Konexioa itxi
Serial.println("bezeroa deskonektatuta");
}
}
153
Gogoratu zer egin behar den arduinoan sartzeko:
Nabigatzailean zure IP publikoa sartu + portua (100): http://zureIPpublikoa/:100/
edo hobeto, zure domeinua + portua (100): http://zureDomeinua.ddns.net/:100/
Hauxe ikusi behar da: konexioa aztertu ea balio analogikoak bat datozen
egindako konexioekin. Hemen, adibidez, 5. sarrera analogikoa GND pinera
konektatu da.
154
9P2 LAN. LED BAT PIZTU WEB-ORRIALDE BATETIK
6. Helburuak
Irteera digital bat piztea da helburua. Oraingoan, Interneten bidez eta HTML
hizkuntza erabilita, bi botoi dituen leiho txiki bat sortuko da.
Atzeko kolorea berdea izango da. PIZTUTA ere berdez agertuko da, eta
ITZALITA, berriz, gorriz.
1. Prozedura

jarriko zaio eta sareko kablea erruterretik arduinora (RJ45 Ethernet kable
estandar bat).
Arduinoari, sarean ikusgai egon dadin, behar duen programa kargatuko zaio.
Ondoren, IP helbidea esleituko zaio.
2. Materiala

Gogora ezazu 10, 11, 12 eta 13 pinak ezin direla erabili, Ethernet Shieldak
erabiliko baititu.
155
4. Kodea
/*
Arduinoa kontrolatu INTERNETEN bidez
SARTZEKO http://zureIPhelbidea/:100/ helbidea erabili arduinoa erruter
rera konektatuta badago
Irteera digital bat ordenagailu baten bitartez piztu eta amatatuko da.
Bi botoidun web-orrialde bat sortuko da HTML formatuan.
*/
#include <SPI.h>
IPAddress ip(169,254,231,252); //IP 169.254.231.252
EthernetServer zerbitzaria(80); // Ethernet zerbitzariaren liburutegia
/*
byte ip[] = { 192, 168, 0, 200 }; // IP lokala 192.168.0.200
byte subnet[] = { 255, 255, 255, 0 };
*/
int Pin4=4;
String readString;
String egoera=String(11);
void setup(){
pinMode(Pin4, OUTPUT); //kontrolatuko den pina; argi bat, adibidez
Ethernet.begin(mac, ip); //Ethernet.begin(mac, ip);

//Ethernet.begin(mac, ip, gateway, subnet); //Ethernet.begin(mac,
ip, gateway, subnet);
egoera="<span style=color:red><font size='6'>ITZALITA</span>";
}
void loop(){
// Konexio-bezero bat sortu
EthernetClient bezeroa = zerbitzaria.available();
if (bezeroa) {
//leer char
if (readString.length() < 100) {
readString += c; }
if (c == '\n') {
///////////////////// pinaren kontrola

if(readString.indexOf("?LED.T") >0) {digitalWrite(Pin4, HIGH);
156
egoera="<span style=color:green><font size='6'>PIZTUTA</span>";}
if(readString.indexOf("?LED.F") >0) {digitalWrite(Pin4, LOW);
egoera="<span style=color:red><font size='6'>ITZALITA</span>";}
//WEB orrialdea sortu:

bezeroa.println();
bezeroa.println("<HTML>");
bezeroa.println("<HEAD>");
bezeroa.println("<TITLE>ARDUINOA KONTROLA</TITLE>");
bezeroa.println("</HEAD>");
bezeroa.println("<BODY>");
bezeroa.println("<body bgcolor=#97FC95 height=100%
width=100%>");
bezeroa.println("<p style=text-align: right;>PLAYGROUND <a
href=http://playground.arduino.cc/ >ARDUINO</a></p>");
bezeroa.println("<H1>ARDUINOA KONTROLA</H1>");
bezeroa.println("<hr />");
bezeroa.println("<br />");
bezeroa.println("<form method=get>");
bezeroa.println("<input type=submit
style=width:100px;height:40px;font-size:'8';font-weight:bold;
name=LED.T value=PIZTU>");
bezeroa.println("<input type=submit
style=width:100px;height:40px;font-size:'8';font-weight:bold;
name=LED.F value=ITZALI>");
bezeroa.println("</form>");
bezeroa.print("<br><br>");
bezeroa.print(egoera);
bezeroa.print("<font size=''> DAGO!!");
bezeroa.println("</BODY>");
bezeroa.println("</HTML>");
delay(1);
bezeroa.stop(); //bezeroa gelditu
readString="";
}
}
}
}
}
Nabigatzailean http://zureDomeinua.ddns.net/:100/ helbidea idazten badugu,

hauxe ikusi behar da:
157
Konprobatu ezazu, led batekin edo polimetroarekin, ea 4. pina piztu eta
itzaltzen den.
158
10. BLOKEA:
APP BAT SORTU ARDUINOA KONTROLATZEKO
159
10. BLOKEA: APP BAT SORTU ARDUINOA KONTROLATZEKO
Helburua
Helburua APP bat sortzea da Arduinoa smartphone edo tablet batetik

Interneten bidez kontrolatzeko. Interes handiko praktika da hau, gure arduinoa
kontrolatu ahal izango dugulako Internetera konexioa dagoen edozein tokitik.
Bi, bereziki, izango dira egitekoak. Bata, arduinoak datuak bidaltzea

smartphoneko APP aplikaziora; esate baterako: tenperatura, hezetasuna, edo
sarrera/irteera digitalak zer egoeratan dauden. Bigarrena, arduinoari aginduak
ematea sarearen bidez: Irteera digital bat piztea edo amatatzea edo irteera
analogiko baten balioa aldatzea, adibidez.
- Telefonorako APP bat sortzen NetIO aplikazioa erabilita

- Sortutako aplikazioa eta telefonoa sinkronizatzen
- Arduinoa eta APPa lotzen
- Arduinoari aginduak ematen telefonoaren bidez
10P1: APP. SARRERA ETA IRTEERA DIGITALAK LANDU

10P2: APP. SARRERA ETA IRTEERA ANALOGIKOAK LANDU
10P3: APP. SARRERA ETA IRTEERA DIGITALAK. TOGGLE
10P4: APP. SARRERA ETA IRTEERA DIGITALAK ETA ANALOGIKOAK
160
NetIO. SARRERA
NetIO aplikazioarekin APPak sortu daitezke. APP (aplikazioak) horietan

etiketak, botoiak, kommutadoreak, graduatzaileak (slider-ak) eta webak
erakusteko laukiak erabili daitezke behar den neurriko interfazeak diseinatzeko
eta arduinoa kontrolatzeko. Hitz gutxitan, telefonoko pantailan sarrera digitalak
eta analogikoak zer egoeratan dauden ikusi daiteke, baita irteera digitalen eta
analogikoen egoera aldatu ere. Hauek dira sortu daitezkeen aplikazioen adibide
batzuk:
Aplikazioa hau ez da dohainik: 5€ balio du Android sistemarako (telefonoa

formateatzen badugu edo modeloa aldatzen badugu, ez da berriro ordaindu
behar). Gainera, NetIO erabiltzeko ETHERNET SHIELD bat ere behar da.
Ordea, aplikazio hau erabiltzen erraza iruditzen zait eta aukera interesgarriak
ditu.
NetIO-k bi atal garrantzitsu ditu. Alde batetik, gure telefonoan edo tabletean
arduinoa kontrolatzeko erabiliko dugun interfazea. Bestetik, interfaze horiek
(APPak) sortzeko editorea.
Interfaze-editorearekin sortutako APPak lainoan gordeko dira, eta, gero, lainotik
smartphonera edo tabletera jaitsiko dira erabiltzeko.
161
Lehenengo pausoa kontu bat sortzea da, eta aplikazioan sartzea. Hemen duzu
NetIO aplikazioan kontua sortzeko linka: http://netio.davideickhoff.de/es/
Web orrialdean gaudenean, diseinuen editorera joko dugu eta interfazeak

diseinatzen hasiko gara.
NetIO EDITOREA: APLIKAZIO BERRIA SORTU ETA GORDE

Interfazeen editorean agertuko den leiho nagusia hau da:
“Open Config” atalean, New/Empty sakatuko dugu interfaze berri bat

sortzeko. Aurretiaz egindako diseinu bat ere ireki daiteke eta moldatu: Default,
hello world, eta abar. Jarraian, guk egindako diseinuak agertuko dira (sortu
baditugu): 1 ARDUINO, 2 SLIDE, eta abar.
162
Diseinua eginda dagoenean, “Save Online” sakatuta, lainoan gordeko da.
NetIO EDITOREA: KONFIGURAZIO OROKORRA EGIN (GLOBAL)

Global: Atal honetan, konfigurazio orokorra beteko da
(IPa, portua eta beste batzuk):
Config Name: interfazeak izango duen izena da.
Interfazea eginda dagoenean, izen horrekin kargatuko
dugu telefonoan.
Description: Aplikazio asko egiten baditugu

komeni da hitz gutxitan azaltzea.
Device: Zer telefonotarako egiten ari garen

aplikazioa. Honekin, APParen neurria
aukeratutako telefonoaren pantailaren neurrira
egokituko da. Zure modeloa agertzen ez bada,
lasai egon. Pantailaren tamaina eskuz moldatu
daiteke eskuman dagoen menuarekin:
“Add Attribute”: sakatu egin behar dugu “initialsend” propietatea ager dadin:
name: konexioari izena emateko aukera dago. Beste diseinu batzuetan

erabiltzeko aukera emango digu izenak.
host: Arduinoak erabiliko duen IPa idatziko dugu: IP pribatua LAN sare batekin
lan egiteko edo IP publikoa Interneten bidez lan egiteko.
port: Portuaren zenbakia, adibidez: 100 Interneterako, 3200 LAN sarerako.
163
initialsend: Komunikazioa hasteko agur bat bidaltzen da. “KaixoArdu”,
adibidez.
Horiek guztiak beteta, prest dago konfigurazio orokorra.
NetIO EDITOREA: ORRIALDEAREN KONFIGURAZIOA EGIN (PAGES)
Pages: Gure interfazeak orrialde bakarra izan dezake edo berriak sortu
daitezke “+Add new page” sakatuta. Orrialdeari nahi den izena emango zaio.
“Label”: Idazten dugun izena

telefonoaren goiko aldean agertuko da.
“Connection”: Hemen, GLOBAL

pantailan konfiguratu den konexioa idatzi
behar da.
NetIO EDITOREA: OSAGAIAK KONFIGURATU (SELECTION)
Orrialdeari osagaiak gehituko dizkiogu “+Add Item” sakatzen badugu. Sartu

daitezkeen osagaiak label, button, slider, switch eta webView dira.
Selection: Orrialdeko osagai bat sakatzen badugu, moldatu egin daitezke

haren ezaugarriak: tamaina, izena, kolorea, bidali edo jaso behar dituzten
balioak, besteak beste.
164
165
Label, button, slider, switch, eta webView-en konfigurazioa azalduko da:
“Add Item” sakatu eta LABEL bat gehitu ondoren, LABEL-a pantailan jarriko
dugu eta neurria emango diogu. Gero, “Add Attribute“ sakatu eta reads,
interval, parseResponse, formatResponse ezaugarriak aukeratuko ditugu:
- reads: Arduinoaren sarrera baten egoera irakurriko du.

- interval: Sarreraren egoera zenbatetik zenbatera irakurriko den (500
ms).
- parseResponse: Pantailan inprimatuko den espresioa: Arduinoak
bidaliko du.
- formatResponse: Erabiliko den formatua: Zenbakientzat, \d+ eta
hizkientzat, O[A-Z]+.
“Add Item” sakatu eta BUTTON bat gehitu ondoren, BUTTON-a pantailan
jarriko dugu eta neurria emango diogu. Gero, “Add Attribute“ sakatu eta sends
aukeratuko dugu. Ezaugarririk inportanteena hau da:
- Sends: Botoia sakatzen denean arduinoari bidaliko zaion datua da.
“Add Item” sakatu eta SLIDER bat gehitu ondoren, SLIDER-a pantailan jarriko
dugu eta neurria emango diogu. Ezaugarririk inportanteenak hauek dira:
- minValue: slider-aren baliorik txikiena.

- maxValue: slider-aren baliorik handiena.
- sends: slider-ak arduinoari bidaliko dion balioa da. Slider-ak bere
posizioaren araberako balioa bidaliko du. SLIDER {value}
adierazpidean, value posizioaren balioa izango da, adibidez, SLIDER
512.
“Add Item” sakatu eta SWITCH bat gehitu ondoren, SWITCH-a pantailan jarriko
dugu eta neurria emango diogu. Ezaugarririk inportanteenak hauek dira:
- onSend: Switch-a ON dagoenean, arduinoari onSend-eko datua

bidaliko zaio.
- offSend: Switch-a OFF dagoenean, offSend-eko datua bidaliko zaio.
166
“Add Item” sakatu eta WEBVIEW bat gehitu dugu. Ezaugarririk inportanteena
da: URL helbide bat sartzeko aukera ematen du eta hala web-orrialde bat
bistaratuko da.
NetIO EDITOREA: OHARRAK
Kontuz!!! read edo send komandoetan erabiltzen diren aldagaiek ezin dute izen
bera izan.
Gogoratu!!! APP bat sortzen baduzu, ez ahaztu orrialde bakoitzari, “Connection”

atalean, “Global” pantailan sortu duzun konexioaren izena jartzea. Orrialde berri
bat sortzen denean “Connection” edit izena du eta eskuz aldatu behar da.
Egiten ez baduzu, izpi gorria agertuko da. Dena ondo badago, tick berdea
agertuko da.
Dena ondo badago:
Ezer gaizki badago:
Formatuei buruz gehiago ikasi nahi baduzu, egin klik hemen:

http://netio.davideickhoff.de/es/documentation/#general
167
10P1: APP. SARRERA ETA IRTEERA DIGITALAK LANDU
1. Helburuak
Lehenengo praktikaren helburua APP bat sortzea da, sarrera eta irteera
digitalak maneiatzeko. Lehenengoa denez, praktika sinple bat egingo dugu:
arduinoarekin komunikatu, sarrera digital baten egoera irakurri eta irteera digital
bat piztu/amatatuko da:
- SWITCH baten bidez, arduinoaren 3. PIN-a piztu/amatatuko dugu.

- LABEL baten bidez, arduinoaren 4. PIN-aren egoera irakurriko dugu:
Pantailan, piztuta edo amatatuta dagoen bistaratuko da
2. Prozedura
- APP garbi bat ireki

- Izena, IPa eta portuaren zenbakia sartu.
- Arduinoarekin komunikazioa ezarri: “KaixoArdu”
- Behar diren orrialdeak eta osagaiak sartu
- Osagaiak arduinoan egindako sketch-arekin lotu
- Sketch-a arduinoan kargatu eta arduinoa konektatu
- APPa telefonoan sinkronizatu eta frogatu
3. Materiala

- NetIO aplikazioa
168
4. APPa sortzeko datuak:
GLOBAL. Gogoratu ezazu

parametro garrantzitsuenak
Config Name, host, port eta
initialsend direla.
SWITCH. Gogoratu ezazu

onSend eta offSend direla.
LABEL. Gogoratu ezazu

reads, interval,
parseResponse eta
formatResponse direla.
169
5. Kodea
#include <SPI.h>
/*
byte mac[] = { 0xDE,0xAD,0xBE,0xEF,0xFE,0xED };
byte ip[] = { 192, 168, 0, 200 }; //192.168.0.200
*/
byte ip[] = { 192, 168, 0, 200 }; // IP lokala 192.168.0.200
byte subnet[] = { 255, 255, 255, 0 };
EthernetServer zerbitzaria(100);
#define BUFFER 10
int ledSwitch = 3;
int ledPultsadorea = 4;
void setup(){
Serial.begin(9600);
Ethernet.begin(mac, ip, gateway, subnet);
pinMode(ledSwitch, OUTPUT);
pinMode(ledPultsadorea, INPUT);
}
void loop()
{
int index = 0;
char komandoa[BUFFER];
EthernetClient appBezeroa = zerbitzaria.available();

if (appBezeroa)
{
if (appBezeroa.connected())
{
while (appBezeroa.available())
{
char karakterea = appBezeroa.read();
if (karakterea != '\n')
{
komandoa[index] = karakterea; index++;
if (index >= BUFFER) index = BUFFER -1;
continue;
}
komandoa[index] = '\0';
}
// Galdetu ea arduinoa prest dagoen.
if (strstr(komandoa, "KaixoArdu")) {appBezeroa.println("done");}
// SWITCH
if (strstr(komandoa, "onBidali")) {appBezeroa.println("OK");
digitalWrite(ledSwitch, HIGH);}
if (strstr(komandoa, "offBidali")) {appBezeroa.println("OK");
digitalWrite(ledSwitch, LOW);}
// LABEL
if (strstr(komandoa, "BOTON")) {
if (digitalRead(ledPultsadorea) == HIGH){appBezeroa.println("ON");}
else {appBezeroa.println("OFF");} }
}
}
170
}
10P2: APP. SARRERA ETA IRTEERA ANALOGIKOAK LANDU
1. Helburuak
Bigarren praktikaren helburua APP bat sortzea da sarrera eta irteera

analogikoak maneiatzeko. Praktika sinple bat egingo dugu: arduinoarekin
komunikatu, sarrera analogiko baten egoera irakurri eta irteera analogiko bat
maneiatu.
 SLIDE baten bidez, arduinoaren 3. PIN-a piztu/amatatuko dugu.

 LABEL baten bidez, arduinoaren A0, A1 eta A2 PIN-en egoera irakurriko
dugu: Hiru tenperaturen balio analogikoa izango da. Tenperatura
minimoa 0 ºC izango da eta maximoa 100 ºC.
2. Prozedura

3. Materiala

- NetIO aplikazioa
171

parametro garrantzitsuenak Config
Name, host, port eta initialsend
direla.
SLIDER. Gogoratu ezazu parametro

garrantzitsuena Sends dela.
parseResponse = \\d+ izango da. (\
d+-k zifra bakarra irakurriko du, eta \\
d+-k bi)
LABEL. Gogoratu ezazu parametro

garrantzitsuenak reads, interval,
parseResponse eta formatResponse
direla.
172
5. Kodea
#include <SPI.h>
/*
byte ip[] = { 192, 168, 0, 200 }; //192.168.0.200
*/
byte ip[] = { 192, 168, 0, 200 }; // IP lokala 192.168.0.200
byte subnet[] = { 255, 255, 255, 0 };
EthernetServer arduinoZerbitzaria(100);
#define BUFFER 10
int led = 3;
void setup(){
Serial.begin(9600);
arduinoZerbitzaria.begin();
}
void loop()
{
int index = 0;
EthernetClient appBezeroa = arduinoZerbitzaria.available();

if (appBezeroa) {
if (appBezeroa.connected()) {
while (appBezeroa.available()) {
if (karakterea != '\n') {
komandoa[index] = karakterea;
index++;
continue;
}
}

// SLIDE
if (strstr(komandoa, "SLID")) {appBezeroa.println("OK");
analogWrite(led, atoi(&komandoa[5])*10);}
//LABEL ANALOGIKOA
if (strstr(komandoa, "irakurri0"))
{int T0= map(analogRead(A0), 0, 1023, 0, 100); appBezeroa.println(T0);}


}
}
}
173
10P3: APP. SARRERA ETA IRTEERA DIGITALAK. TOGGLE
1. Helburuak
Hirugarren praktikaren helburua APP bat sortzea da sarrera eta irteera digitalak
maneiatzeko. Praktika sinple bat egingo dugu: arduinoarekin komunikatu,
sarrera digitalen zer egoeratan dauden irakurri eta irteera digitalak
piztu/amatatuko dira. Irteerak piztu/amatatzeko, TOGGLE egingo da, hau da,
irteeren egoera aldatzeko botoi bakar bat erabiliko da.
 SARRERA DIGITALAK: 6., 7., 8. eta 9. pinak izango dira.

 IRTEERA DIGITALAK: 2., 3., 4. eta 5. pinak izango dira.
2. Prozedura

3. Materiala

- NetIO aplikazioa
174
GLOBAL. Gogoratu ezazu parametro garrantzitsuenak Config Name, host, port

eta initialsend direla.
175
5. Kodea
#include <SPI.h>
/*
byte ip[] = { 192, 168, 0, 200 }; //192.168.0.200
*/
byte ip[] = { 192, 168, 0, 200 }; // IP lokala 192.168.0.200
byte subnet[] = { 255, 255, 255, 0 };
#define BUFFER 10
//IRTEERA DIGITALAK
int ID2 = 2; int ID3 = 3; int ID4 = 4; int ID5 = 5;
//SARRERA DIGITALAK
int SD6 = 6; int SD7 = 7; int SD8 = 8; int SD9 = 9;
void setup(){
Serial.begin(9600);
//SD SARRERA DIGITALA, ETA ID IRTEERA DIGITALAK:
pinMode(SD6, INPUT); digitalWrite(SD6, HIGH); pinMode(SD7, INPUT); digitalWrite(SD7, HIGH);

pinMode(SD8, INPUT); digitalWrite(SD8, HIGH); pinMode(SD9, INPUT); digitalWrite(SD9, HIGH);
pinMode(ID2, OUTPUT); pinMode(ID3, OUTPUT); pinMode(ID4, OUTPUT); pinMode(ID5, OUTPUT);
}
void loop()
{
int index = 0;

if (appBezeroa) {
index++;
continue;
}
}

// BOTOIAK
if (strstr(komandoa, "3_BOTOIA2")) {appBezeroa.println("OK"); digitalWrite(ID2,!digitalRead(ID2));}
// LABEL DIGITALA: SARRERAK
if (strstr(komandoa, "3_PIN6")) {
if (digitalRead(SD6) == HIGH){appBezeroa.println("ON");} else {appBezeroa.println("OFF");} }
// LABEL DIGITALA: IRTEERAK

if (digitalRead(ID2) == HIGH){appBezeroa.println("ON");} else {appBezeroa.println("OFF");} }
}
}
}
176
10P4: APP. SARRERA ETA IRTEERA DIGITALAK ETA
ANALOGIKOAK
1. Helburuak
Hirugarren praktikaren helburua APP bat sortzea da, sarrera eta irteera
digitalak eta analogikoak maneiatzeko. Arduino Duemilanove txartela
kontrolatzen duen praktika sinple bat egingo dugu: Aplikazioak hiru orrialde
izango ditu: PORTADA, DIGITALAK, eta ANALOGIKO.
 PORTADA: Testua sartuko da eta Duemilanoveren web-orrialdea.

 DIGITALAK: 2., 3. eta 4. pinen egoera irakurriko da: ON/OFF.
7., 8. eta 9. pinak piztu/amatatu egingo dira.
 ANALOGIKO: A0-A5 sarrerak irakurriko dira eta 0-5 V tarteko volt
balioetan emango dira
PWM irteerak: 5. eta 6. pinak SLIDE-rekin kontrolatuko dira.
2. Prozedura

3. Materiala

- NetIO aplikazioa
177

parametro garrantzitsuenak Config
Name, host, port eta initialsend
direla.
PAGE. PORTADA
Testua sartuko dugu LABEL batzuen

bidez, eta WEBVIEW baten bidez
Duemilanoveren web-orrialde hau,
zalantzarik badugu kontsultatzeko:
http://arduino.cc/en/pmwiki.php?
n=Main/arduinoBoardDuemilanove
178
PAGE. DIGITALAK
PAGE. ANALOGIKOAK
179
5. Kodea
#include <SPI.h>
/*
byte ip[] = { 192, 168, 0, 200 }; //192.168.0.200
*/
byte ip[] = { 192, 168, 0, 200 }; // IP lokala 192.168.0.200
byte subnet[] = { 255, 255, 255, 0 };
#define BUFFER 10
int led7 = 7; int led8 = 8; int led9 = 9; //IRTEERA DIGITALAK

int SLIDE5 = 5; int SLIDE6 = 6; //IRTEERA ANALOGIKOAK
int pin2 = 2; int pin3 = 3; int pin4 = 4; //SARRERA DIGITALAK
void setup(){
Serial.begin(9600);
pinMode(led7, OUTPUT); pinMode(led8, OUTPUT); pinMode(led9, OUTPUT);
pinMode(SLIDE5, OUTPUT); pinMode(SLIDE6, OUTPUT);
void loop()
{
int index = 0;

if (appBezeroa) {
index++;
continue;
}
}

// SWITCH
if (strstr(komandoa, "onsend7")) {appBezeroa.println("OK"); digitalWrite(led7, HIGH);}
if (strstr(komandoa, "offsend7")){appBezeroa.println("OK"); digitalWrite(led7, LOW);}
// SLIDE
if (strstr(komandoa, "SLIDE5")) {appBezeroa.println("OK"); analogWrite(SLIDE5,
atoi(&komandoa[7])*10);}
if (strstr(komandoa, "SLIDE6")) {appBezeroa.println("OK"); analogWrite(SLIDE6,
atoi(&komandoa[7])*10);}
// LABEL DIGITALA

if (strstr(komandoa, "2. PIN")) {
if (digitalRead(pin2) == HIGH){appBezeroa.println("ON");} else {appBezeroa.println("OFF");} }
//LABEL ANALOGIKOA
if (strstr(komandoa, "A0")){int T0= map(analogRead(A0), 0, 1023, 0, 100); appBezeroa.println(T0);}
}
}
}
180
181
11. BLOKEA:
BLUETOOTH
182
11. BLOKEA: BLUETOOTH
Helburua
Arduinoa Bluetooth bidez kontrolatzea da helburua. Bluetooth konektibitatea

izateko, HC-05 txartela erabiliko da.
Arduinoari Bluetooth bidez emango zaizkio aginduak: Irteera digital bat piztu
edo amatatu, sarrera analogiko bat irakurri. Smartphone batetik emango
dizkiogu aginduak arduinoari.
- Arduinoari HC-05 bluetooth txartel bat konektatzen

- HC-05 bluetooth txartela konfiguratzen eta hari aginduak ematen
11P1: HC05. TXARTEL BAT EGIAZTATU

11P2: HC05. TXARTELAREKIN LED BAT PIZTU
11P3: HC05. TXARTELA KONFIGURATU. AT KOMANDOAK
11P4: HC05. SARRERA ANALOGIKO BATEN BALIOA SMARTPHONEAN
11P5. HC05. ARDUDROID
11P6: HC05. BLUETOOTH SPP PRO APLIKAZIOA
11P7: HC05. ATC LITE APLIKAZIOA
183
TEORIA APUR BAT
Bluetooh transmisioetan, HC05 txartelak serie-portu bat behar du arduinoarekin

komunikatzeko eta datuak trukatzeko. Arduinoek serie-portua dute RX eta TX
terminaletan. RX terminaletik datuak jasoko ditu, eta TX terminaletik datuak
bidaliko ditu. Pin horiek, RX eta TX, arduinoaren 0 eta 1 pinak dira, hurrenez
hurren.
Kode berri bat egiten dugunean, serie-monitorearekin testeatuko dugu, eta

ondo dagoenean konektatuko dugu HC05 txartela. Zergatik testeatu serie-
monitorearekin? Bada, arduinoak serie-portua erabiltzen duelako serie-
monitorearekin komunikatzeko, eta HC05 txartelarekin komunikatzeko ere bai.
Beraz, bermea dugu serie-monitorearekin testeatutako kodea zuzen badago
bluetooth txartel batekin ere funtzionatuko duela.
Kontuz! Arduino gehienek serie-portu bakarra daukate, eta arduinoan kodeak

kargatzeko serie-portua erabiliko denez, HC05 txartela ezingo da egon une
horretan serie-portura konektatuta. Gainera, arduinoan serie-monitorea
erabiltzen bada, ezin daiteke une horretan HC05 txartelarekin komunikatu, biek
serie-portua erabiltzen baitute.
Interesgarria da arduinoan bigarren serie-portu bat sortzea, serie-

monitorearekin edo beste osagaiekin arazorik ez izateko HC05 txartela erabili
nahi dugunean. Horretarako, SoftwareSerial.h liburutegia gehitu behar da, izena
eman behar zaio eta zer pin erabiliko diren adierazi:
#include <SoftwareSerial.h>
SoftwareSerial nirePortua(2,3); // Arduinoan sortutako serie-portu berria (Rx, Tx)
Arduinoaren serie-portua erabiltzeko komandoak hauek izan badira,
Serial.begin(9600);
Serial.println("Konexioa egin da!");
arduinoaren serie-portu berria erabiltzeko komandoak beste hauek izango dira:
nirePortua.begin(9600);
nirePortua.println("Konexioa egin da!");
184
11P1: HC05. TXARTEL BAT EGIAZTATU
1. Helburuak
Helburua da HC05 txartela testeatzen ikastea.
2. Prozedura
Txartela badabilela egiaztatzeko egingo ditugun frogak hauek dira:
1. HC05 txartelari elikadurako kable biak konektatuko dizkiogu. Txartela

elikatuta dagoenean, LEDak keinuka hasi behar du.
2. Bluetooth-a duen smartphone bat gertu jarrita, zer ekipo dauden
konektagai bilatuko dugu. HC-05 txartela egindako bilaketan agertzen
bada, seinale ona da.
3. Smartphonean, HC05 txartela parekatzea sakatuko dugu. Orduan, HC05
moduluak pasahitza eskatuko digu: 1234 da (aurrerago ikusiko da zelan
aldatu). Parekatzen denean, HC05 txartelaren LEDa ez da keinuka
egongo eta piztuta geratuko da.
Egiaztapen hauek zuzenak badira, ondo! Laster izango duzu martxan HC05
txartela!
3. Materiala

- HC05 bluetooth txartel bat
Konekta itzazu elikadurako kable biak. Oraingoz, gainerako kableak konektatu

barik utziko dira.
ARDUINOA HC05
+5V +Vcc
GND GND
185
11P2: HC05. TXARTELAREKIN LED BAT PIZTU
1. Helburuak
Helburua da HC05 txartelarekin LED bat piztea.
2. Prozedura
Lehenago esan dugu: Bermea dugu serie-monitorearekin testeatutako kodeak

Bluetooth txartel batekin funtzionatuko duela. Beraz, SERIE-MONITOREA
blokean erabilitako praktika, P4 LED BAT PIZTU SERIE-MONITORETIK,
berrerabiliko dugu, eta oraingoan, HC05 bluetooth txartela erabiliko dugu leda
pizteko.
Ordenagailuarekin, serie-monitorea erabili da. Smartphone batekin serie-

monitorearen antzeko bat sortzeko, APPak erabiliko ditugu: “BlueTerm”,
“Bluetooth spp pro” edo “ATC lite” esate baterako. Horiekin, konprobatuko dugu
HC05-en eta Smartphonearen artean komunikazioa dagoela. Oraingoan,
BlueTerm aplikazioaren bidez egingo dugu:
1. BlueTerm APPa jaitsiko dugu smartphonera. Aplikazioa doanekoa da.

2. HC05 txartela konektatuko dugu: Bakarrik elikadura: +Vcc eta GND.
3. Smartphoneko bluetooth-a piztuko dugu.
4. BlueTerm aplikazioa irekiko dugu eta “Connect device” sakatuko dugu.
5. HC05 txartela smartphonerakin parekatuko dugu. Pasahitza sartu.
6. BlueTerm-en pantailan, goialdean, “connected: HC05” agertuko da.
Komunikazioa badago, jarraitu egingo dugu:
7. Txartelaren konexioak kenduko ditugu (Programa kargatzeko serie-

portua erabiliko da) eta kodea arduinoan kargatuko dugu.
8. Konexioak egin: 2 kable elikadurarako eta bi kable transmisiorako.

Gogoratu arduinoaren TX pina HC05 txartelaren RX pinarekin
konektatuko dela, eta arduinoaren RX pina HC05 txartelaren TX
pinarekin konektatuko dela.
186
9. p/a sakatu, LEDa piztu/amatatzeko.
3. Materiala
BLUETOOHA ARDUINOA
Vcc +5V
GND 0V
RXD TX2 (PIN 3)
TXD RX2 (PIN 2)
5. Kodea:
Arduinoaren serie-portuaren (RX, TX) pinak erabilita

/*
Oraingoan irteera digital bat piztuko da.
Arduinoaren serie-portua erabiliko da. Hurrengo bertsioan, beste portu bat era
biliko da
*/
char jasoAginduak; // BlueTerm aplikaziotik jasoko diren datuak aldagai

honetan gordeko dira
void setup()
{
Serial.begin(9600);
Serial.println("p/a sakatu LEDa pizteko/amatatzeko");
}
void loop()
{
if( Serial.available() ){
jasoAginduak = Serial.read(); // Byte bat irakurri eta aldagaian gorde
if(jasoAginduak == 'p' ){digitalWrite(led13, HIGH); Serial.println("PIN 13
ON");}
if(jasoAginduak == 'a' ){digitalWrite(led13, LOW); Serial.println("PIN 13
OFF");}
}
187
delay(100);
}
Kodea. Arduinoaren serie-portu berriaren pinak (2 eta 3) erabilita
/*
Oraingoan irteera digital bat piztuko da.
Arduinoak datuak RX eta TX pinetatik jaso eta bidali beharrean, 2 eta
3 pinetatik jaso eta bidaliko ditu (Rx2, Tx2)
*/
SoftwareSerial nirePortua(2,3); // Arduinoan sortutako serie-portua
(Rx, Tx)
char jasoAginduak; // BlueTerm aplikaziotik jasoko diren datuak

aldagai honetan gordeko dira
void setup()
{
nirePortua.println("p/a sakatu LEDa pizteko/amatatzeko");
}
void loop()
{
if( nirePortua.available() ){
jasoAginduak = nirePortua.read(); // Byte bat irakurri eta aldagaian
gorde
if(jasoAginduak == 'p' ){digitalWrite(led13, HIGH);
nirePortua.println("PIN 13 ON");}
if(jasoAginduak == 'a' ){digitalWrite(led13, LOW);
nirePortua.println("PIN 13 OFF");}
}
delay(100);
}
188
11P3: HC05. TXARTELA KONFIGURATU. AT KOMANDOAK
1. Helburuak
Helburua da HC05 txartela testeatzea eta konfiguratzea AT komandoen bidez.
2. Prozedura
AT komandoak erabiltzen dira txartela testeatzeko eta konfiguratzeko.
Txartela testeatzeko erabili praktika honetan agertzen den programa. Programa

kargatutakoan, HC-05 txartelari serie-monitorearen bidez AT komandoa
bidaltzen zaio. HC-05 txartelaren erantzuna “OK” bada, txartelak ondo
funtzionatzen duela esan nahi du: Txartelak entzuteko eta erantzuteko
gaitasuna du.
Txartelaren konfigurazioan ohiko parametro batzuk aldatuko dira.
3. Materiala

BLUETOOHA ARDUINOA
Vcc +5V
GND 0V
RXD TX2 (PIN 3)
TXD RX2 (PIN 2)
ENABLE +5V
189
5. Kodea
/*
AT komandoak erabili. HC-05 Bluetooth txartela testeatu
*/
SoftwareSerial nirePortua(2,3); // Arduinoan sortutako serie-portua (Rx, Tx)
void setup()
{
Serial.begin(9600);
Serial.println ("AT komandoak hasieratu:");
}
void loop()
{ // HC-05 moduloak irakurriko ditu serie-monitoretik bidalitako AT komandoak
if(Serial.available()) nirePortua.write(Serial.read());
// Serie-monitoreak irakurriko ditu HC-05 modulotik bidalitako AT komandoen erantzuna
if(nirePortua.available()) Serial.write(nirePortua.read());
}
Konexioa egin ondoren, testeatuko dugu ea HC-05 txartelak funtzionatzen

duen.
Bluetooth txartela konfiguratuko dugu. Horrekin, lehenengo, ziurtatuko dugu

txartelak bere lana egiten duela, eta gero, HC-05 txartelarekin komunikatuko
gara komando batzuen bidez (AT komandoak) eta konfiguratu egingo dugu:
izena, pasahitza, eta beste hainbat parametro alda daitezke.
HC-05 txartelarekin komunikatzeko, serie-monitorea erabiliko da. Lehenengo,

AT komandoarekin egiaztatuko dugu funtzionatzen duela txartelak. Beste
komando batzuekin ere egin daiteke, baina, horien funtzioa txartela
konfiguratzea izango da. Serie-monitorea irekiko dugu eta 9600 Baudioko
abiadura eta "Ambos NL & CR" aukeratuko ditugu.
190
Oinarrizko AT komando hauek sartuko dira HC05 txartela konfiguratzeko:
KOMANDOA ERANTZUNA ERABILERA

HC06 moduluarekin
AT OK
komunikazioa dago.
Transferentziaren
AT+UART +UART : 9600,0,0 / OK
abiadura
Transferentziaren
AT+UART = 115200,0,0 OK
abiadura aldatu
Txartelaren izena
AT+NAME izena
galdetu
Txartelaren izena
AT+NAME = "izena” OK
aldatuko du
Txartelaren pasahitza
AT+PSWD Pasahitzaren zenbakia
kontsultatu
Txartelaren pasahitza
AT+PSWD=9876 OK
aldatu
AT komando gehiago behar baduzu, kontsultatu esteka hau:
http://www.linotux.ch/arduino/HC-
0305_serial_module_AT_commamd_set_201104_revised.pdf
191
11P4: HC05. SARRERA ANALOGIKO BATEN BALIOA
SMARTPHONEAN
1. Helburuak
Helburua da HC05 txartelarekin tenperatura bat irakurtzea eta BlueTerm

aplikazioan bistaratzea. Dena den, beste edozein sarrera edo irteera digital zein
analogiko ere bistaratu daiteke.
2. Prozedura
Badakigu txartela egiaztatzen eta konfiguratzen. Gainera, serie-monitorearen

funtzioa betetzen duen APPa erabiltzen ere badakigu. Hori guztia aplikazio
erraz batean aplikatuko dugu pauso hauek jarraituta:
Kodea arduinoan kargatu, konexioak egin, BlueTerm aplikazioa ireki eta HC05
txartela parekatu. Pasahitza sartuta smartphonean, pantailan segundoero
tenperatura agertuko da.
3. Materiala

BLUETOOHA ARDUINOA
Vcc +5V
GND 0V
RXD TX2 (PIN 3)
TXD RX2 (PIN 2)
192
5. Kodea
/*
A0 sarrera analogikoan dagoen balioa irakurri eta BlueTerm aplikaziora
bidali
*/
SoftwareSerial nirePortua(2,3);
int sarreraA0=0;
void setup(){
nirePortua.println("Konektatu da!!");
}
void loop(){
sarreraA0 = analogRead(A0);
nirePortua.print("A0 irakurketa:"); nirePortua.println(sarreraA0);
delay(1000);
}
193
11P5: HC05. ARDUDROID
1. Helburuak
Helburua da HC05 txartelarekin eta ARDUDROID aplikazioarekin sarrera eta

irteera digitalak eta analogikoak kontrolatzea.
2. Prozedura
Kodea arduinoan kargatu, konexioak egin, ARDUDROID aplikazioa ireki eta

HC05 txartela parekatu. Pasahitza sartu eta arduinoa kontrolatu.
Programa hau prestatuta dago oinarrizko kontrol bat egiteko. Adibidez,

sakatzen badugu 13. botoia, 13. irteera digitala piztuko da. Berriro sakatuta,
amatatu egingo da. Beste funtzionamendu mota bat behar izanez gero, kodean
sartu daiteke.
Informazio gehiago behar baduzu, klikatu hemen:
http://www.techbitar.com/ardudroid-simple-bluetooth-control-for-arduino-and-android.html
3. Materiala

194
BLUETOOHA ARDUINOA
Vcc +5V
GND 0V
RXD TX2 (PIN 3)
TXD RX2 (PIN 2)
195
5. Kodea
/*
Proiektua: ArduDroid
EGILEA: Hazim Bitar (techbitar at gmail dot com)
Lizentzia: Public domain
*/
#define START_CMD_CHAR '*'
#define END_CMD_CHAR '#'
#define DIV_CMD_CHAR '|'
#define CMD_DIGITALWRITE 10
#define CMD_ANALOGWRITE 11
#define CMD_TEXT 12
#define CMD_READ_ARDUDROID 13
#define MAX_COMMAND 20
#define MIN_COMMAND 10
#define IN_STRING_LENGHT 40
#define MAX_ANALOGWRITE 255
#define PIN_HIGH 3
#define PIN_LOW 2
String inText;
void setup() {
Serial.begin(9600);
Serial.println("ArduDroid 0.12 Alpha by TechBitar (2013)");
Serial.flush();
}
void loop()
{
Serial.flush();
int ard_command = 0;
int pin_num = 0;
int pin_value = 0;
char get_char = ' '; //Serie-irakurketa
// itxaron datuak jaso arte

if (Serial.available() < 1) return;
// Hasteko, komandoa heldu arte itxaron. Heltzen ez bada, itxaron.

get_char = Serial.read();
if (get_char != START_CMD_CHAR) return;
// Komandoa irakurri

ard_command = Serial.parseInt();
// Pinak zer zenbaki duen irakurri, eta zer balio duen
pin_num = Serial.parseInt(); // pinaren zenbakia irakurri
pin_value = Serial.parseInt(); // balioa irakurri
// 1) ARDUDROID-etik testu komandoak exekutatu

if (ard_command == CMD_TEXT){
inText =""; //aldagaia garbitu
while (Serial.available()) {
char c = Serial.read(); //serie-bufferretik byte bat irakurri
delay(5);
if (c == END_CMD_CHAR) { // esaldi osoa irakurri bada...
// GEHITU HEMEN ZURE KODEA
digitalWrite(13, !digitalRead(13));
break;
}
else {
if (c != DIV_CMD_CHAR) {
inText += c;
delay(5);
}
}
}
}
// 2) ARDUDROIDETIK IRTEERA DIGITALAK IDATZI

if (ard_command == CMD_DIGITALWRITE){
if (pin_value == PIN_LOW) pin_value = LOW;
else if (pin_value == PIN_HIGH) pin_value = HIGH;
else return; // Errorea PIN balioan
set_digitalwrite( pin_num, pin_value); // PIN digitalak erabiltzeko funtzioa
return;
}
// 3) ARDUDROIDETIK IRTEERA ANALOGIKOAK IDATZI
196
if (ard_command == CMD_ANALOGWRITE) {
analogWrite( pin_num, pin_value );
return;
}
// 4) DATUAK BIDALI ARDUDROIDERA

if (ard_command == CMD_READ_ARDUDROID) {
// char send_to_android[] = "Jarri hemen zure testua" ;
// Serial.println(send_to_android); // Adibidea: Testua bidaltzen
Serial.print(" Analog 0 = ");
Serial.println(analogRead(A0)); // Adibidea: Irakurri eta bidali sarrera analogikoa arduinora
return;
}
}
// 2a) SAKATU DUZUN PIN DIGITALAREN AKZIOA
void set_digitalwrite(int pin_num, int pin_value)
{
switch (pin_num) {
case 13:
pinMode(13, OUTPUT);
digitalWrite(13, pin_value);
break;
case 12:
break;
case 11:
break;
case 10:
break;
case 9:
pinMode(9, OUTPUT);
break;
case 8:
pinMode(8, OUTPUT);
// add your code here
break;
case 7:
pinMode(7, OUTPUT);
break;
case 6:
pinMode(6, OUTPUT);
// add your code here
break;
case 5:
pinMode(5, OUTPUT);
break;
case 4:
pinMode(4, OUTPUT);
break;
case 3:
pinMode(3, OUTPUT);
break;
case 2:
pinMode(2, OUTPUT);
break;
}
}
197
198
11P6: HC05. BLUETOOTH SPP PRO APLIKAZIOA
1. Helburuak
Helburua da HC05 txartelarekin eta “BLUETOOTH SPP PRO” aplikazioarekin

sarrera eta irteera digitalak eta analogikoak kontrolatzea.
2. Prozedura
Aplikazioa smartphonera jaitsi eta konfiguratu egingo da. Botoiak besterik ez

dira konfiguratuko. Botoi bakoitzari kode bat esleituko zaio. Botoi hori
sakatzean, aplikazioak botoiak duen komando hori bidaliko dio arduinoari eta
arduinoak exekutatu egingo du.
Konfigurazioa hau da: Aplikazioa ireki, “keyboard mode” sakatu botoiak agertu
daitezen. “buttons set” sakatu botoiak konfiguratzeko: Berton, botoiari, izena
jarriko eta komando bat esleituko diogu, “A”, adibidez:
Kodea arduinoan kargatu, konexioak egin, ATC aplikazioa ireki eta HC05
txartela parekatu. Pasahitza sartu eta arduinoa kontrolatu.
L1-L8 pultsadoreak sakatzean, irteera digitalaren balioa aldatuko da: Piztuta

badago, amatatu egingo da, eta amatuta badago, piztu egingo da.
L9 eta L10 pultsadoreak sakatzean irteera digitala piztu egingo da eta

askatzean amatatu egingo da.
3. Materiala
199
BLUETOOHA ARDUINOA
Vcc +5V
GND 0V
RXD TX2 (PIN 3)
TXD RX2 (PIN 2)
5. Kodea
/*
Praktika honek BLUETOOTH SPP PRO aplikazioak bidaltzen dituen komandoak exekutatuko ditu.
10 irteera digital kontrolatuko dira.
Smartphonearen pantailan sakatutako pultsadoreak irteera digitalak piztu/amatatuko ditu.
Arduinoak datuak RX eta TX pinetatik jaso eta bidali beharrean, 2 eta 3 pinetatik jaso eta
bidaliko ditu (Rx2, Tx2)
*/
SoftwareSerial nirePortua (2,3); // Arduinoan sortutako serie-portua (Rx, Tx)
char jasoAginduak; // BlueTerm aplikaziotik jasoko diren datuak aldagai honetan gordeko dira
// Piztu/amatatuko ditugun irteera digitalak:
int ID4 = 4; int ID5 = 5; int ID6 = 6; int ID7 = 7; int ID8 = 8; int ID9 = 9;
int ID10 = 10; int ID11 = 11; int ID12 = 12; int ID13 = 13;
void setup()
{
// Irteera digitalak konfiguratu:
pinMode(ID12, OUTPUT); pinMode(ID13, OUTPUT);
nirePortua.println("IRTEERA DIGITALAK KONTROLATU");
}
void loop()
{
if( nirePortua.available() ){
jasoAginduak = nirePortua.read(); // Byte bat irakurri eta aldagaian gorde
if(jasoAginduak == 'A' ){digitalWrite(ID4, !digitalRead(ID4)); nirePortua.println("ID4
TOGGLE");}
if(jasoAginduak == 'B' ){digitalWrite(ID5, !digitalRead(ID5)); nirePortua.println("ID5
TOGGLE");}
if(jasoAginduak == 'C' ){digitalWrite(ID6, !digitalRead(ID6)); nirePortua.println("ID6
TOGGLE");}
if(jasoAginduak == 'D' ){digitalWrite(ID7, !digitalRead(ID7)); nirePortua.println("ID7
TOGGLE");}
if(jasoAginduak == 'E' ){digitalWrite(ID8, !digitalRead(ID8)); nirePortua.println("ID8
TOGGLE");}
if(jasoAginduak == 'F' ){digitalWrite(ID9, !digitalRead(ID9)); nirePortua.println("ID9
TOGGLE");}
if(jasoAginduak == 'G' ){digitalWrite(ID10, !digitalRead(ID10)); nirePortua.println("ID10
TOGGLE");}
if(jasoAginduak == 'H' ){digitalWrite(ID11, !digitalRead(ID11)); nirePortua.println("ID11
TOGGLE");}
if(jasoAginduak == 'I' ){digitalWrite(ID12, HIGH); nirePortua.println("ID12");}
if(jasoAginduak == 'i' ){digitalWrite(ID12, LOW); nirePortua.println("ID12");}
if(jasoAginduak == 'J' ){digitalWrite(ID13, HIGH); nirePortua.println("ID13");}
if(jasoAginduak == 'j' ){digitalWrite(ID13, LOW); nirePortua.println("ID13");}
}
delay(100);
}
200
201
11P7: HC05. ATC LITE APLIKAZIOA
1. Helburuak
Helburua da sarrera eta irteera digitalak eta analogikoak

kontrolatzea HC05 txartelarekin eta “Arduino Total Control”
aplikazioarekin.
2. Prozedura
ATC LITE smartphonera jaitsiko da, eta konfiguratu. Botoiak besterik ez dira
konfiguratuko. Botoi bakoitzari kode bat esleituko zaio. Botoi hori sakatzean,
ATC LITEk botoiak duen komando hori bidaliko dio arduinoari eta arduinoak
exekutatu egingo du.
Konfigurazioa hau da: ATC LITE programa ireki, “Edit Properties” sakatu eta
konfiguratu nahi den botoia sakatu. “Data sent on touch” sakatzen badugu, hor
bidali nahi den kodigoa idatziko dugu, “A”, adibidez.
Kodea aplikazioan bertan eskuratu daiteke “Arduino CODE!!!” sakatuta. Kodea

arduinoan kargatu, konexioak egin, ATC aplikazioa ireki eta HC05 txartela
parekatu. Pasahitza sartu eta arduinoa kontrolatu.
3. Materiala

202
BLUETOOHA ARDUINOA
Vcc +5V
GND 0V
RXD TX2 (PIN 3)
TXD RX2 (PIN 2)
5. Kodea
Praktika honen kodea aplikazioan bertan duzu. Emailera bidali dezakezu.

ETHERNET shield batekin lotzeko aukera du. Horrek bereziki interesgarria
egiten du aplikazioa. Gainera doan da.
Programazio maila ona izan behar da ATC LITE programari etekina
ateratzeko. Maila ematen baduzu, programak ematen dituen aukerak ia
mugagabeak dira.
ATC LITE ordaintzeko bertsioa ere badago. Programatzeko gogoa baduzu,
seguru merezi duela 1,76€ ordaintzea.
203
12. BLOKEA:
VELLEMAN K8056
204
12. BLOKEA: RS232 BIDEZ VELLEMAN K8056 KONTROLATU
Helburua
Velleman K8056 errele-txartela kontrolatzea. Kontrolatzeko, RS232 protokoloa

erabiliko da. Protokolo horrekin, eta bi kablerekin, 8 errele kontrolatuko dira.
Behin errele-txartela martxan jartzen ikasten dugunean, erreleak urrutiko

agintearekin kontrolatuko ditugu.
- RS232 protokoloa erabiltzen

- Max3232 txarteltxoaren konexioak egiten
- Velleman K8056 errele-txartela kableatzen
- Arduinoa eta MAX3232 txartela erabiltzen, RS232 protokoloaren bidez
Velleman K8056 errele-txartela kontrolatzen
12P1: K8056. TXARTELA TESTEATU

12P2: K8056. INFRAGORRIEN BITARTEZ TXARTELA KONTROLATU
205
Velleman K8056 txartelak 8 errele ditu. Horiek, hainbat eratan kontrolatu
daitezke:
- Zubiak jarrita txartelean bertan

- “Open colector” irteerekin.
- RS232 kontrolarekin: RF urrutiko seinaleekin
- RS232 komandoak erabilita
- Test softwarearekin
Guk RS232 komandoekin aktibatuko dugu txartela.
RS232 Komandoak
Txartelak hainbat komando ditu, Clear, Set eta Toggle dira garrantzitsuenak:
 E: Emergentzia. Txartel guztiak gelditzen ditu. Kontuz, ez ditu itzaliko

“open colector” irteerekin piztutako erreleak.
 D: Helbideak. Txartel guztiek beren helbideak aurkeztuko dituzte,
binarioan. (LD1: MSB, LD8: LSB)
 S: Errele bat piztu (SET). Komandoa errele bat pizteko erabili daiteke: S
komandoari jarraituta relay # ‘1’ to ‘8’ agertu behar da (9 jarriz gero, errele
guztiak piztuko ditu).
 C: Errele bat piztu (SET). Komandoa errele bat pizteko erabili daiteke: C
komandoari jarraituta relay # ‘1’ to ‘8’ agertu behar da (9 jarriz gero, errele
guztiak itzaliko ditu).
 T: Errele baten egoera aldatu (TOGGLE). Komandoa errele bat pizteko
erabili daiteke: T komandoari jarraituta relay # ‘1’ to ‘8’ agertu behar da.
 A: Txartel baten helbidea aldatzen du. Komandoa idatzi behar da eta
haren ostean txartelaren helbideaa: 1-255.
 F: Txartel guztiek 1 helbidea izango dute
 B: Byte bat bidali. Errele guztien egoera instrukzio bakar batekin (byte
bat) kontrolatu daiteke byte horren bit bakoitzean errele bakoitza zer
egoeratan egon behar den adierazita (MSB: relay1, LSB: relay8).
206
Komandoak bidaltzeko sekuentzia, hau da:
1. CHR$(13)
2. card address (1..255)
3. instruction
4. address (1..255) or relay# (‘1′..’9′ ASCII)
5. checksum (2-complement of the sum of the 4 previous bytes + 1)
Sekuentzia hori bi alditan bidali behar da txartelak ondo ulertu dezan.
Ez ahaztu baud ratea 2400 dela.
Velleman Liburutegia
Alban S. Tilanusek Velleman txartela kontrolatzeko liburutegia sortu du.
Liburutegi horrekin, RS232 komandoak erraz erabili daitezke orain arte erabili
dugun ohiko programazio motarekin. Hitz gutxitan, K8056 txartela erraz
kontrolatu daiteke Albanek sortu duen liburutegiarekin. Hauek izango dira
erreleak aktibatzeko gure programetan erabiliko diren komandoak:
Errele bat piztu, 1etik 8ra. 9 jartzen badugu, guztiak piztuko dira:
Relay.ON(1,4); Relay.digitalWrite(1,9,HIGH);
Errele bat itzali, 1etik 8ra. 9 jartzen badugu, guztiak itzaliko dira:
Relay.OFF(1,4); Relay.digitalWrite(1,9,LOW);
Errele baten egoera aldatu: Piztu, itzalita badago, edo itzali, piztuta badago:
Relay.Toggle(1,4);
Errele guztiak itzali:
Relay.EmergencyStop();
Gogoratu liburutegi hau eskuz gehitu behar dela. Liburutegi hau liburutegien
karpetan izango duzu.
207
Konexioak
Arduinoaren serie-portuek TTL irteera dute; beraz, ez dira bateragarriak RS232
sistemarekin. Bateragarri egiteko, TTL-RS232 bihurgailu bat erabili behar da.
TTL balioak erraz moldatu daitezke RS232 balioetara SparkFun-en MAX3232
bihurgailuarekin. Horixe da proiektu honetan erabili den bihurgailua. Konexioak
hauek dira:
Arduinoa MAX3232 K8056

Tx T1IN
Rx (optional) T1OUT IN
Gnd Gnd 0
+5V 3V-5.5V
Velleman K8056 txartelaren JUMPER-ak

JUMPERRAK POSIZIOA
JP1 ON
JP2 RS232
JP3 Normal
208
P1: K8056. TXARTELA TESTEATU
1. Helburuak
Velleman K8056 errele-txartela kontrolatzea. 8 errele kontrolatuko dira.

Kontrolatzeko, RS232 protokoloa erabiliko da.
Erreleak piztu, amatatu eta haien egoera aldatu behar da. Baita guztiak batera
piztu edo amatatu ere.
2. Prozedura
Programa kargatu, eta erreleak piztu eta amatatzeko egindako programaren

sekuentzia jarraituko dugu. Egiaztatu ezazu erabilitako komandoek egin
beharreko funtzioa betetzen dutela.
3. Materiala

- Velleman K8056 txartela
- RS3232 bihurgailua
4.
209
5. Kodea
/*
Velleman K8056 txartelaren kontrola
Egilea: Alban.S. Tilanus
*/
#include <K8056Velleman.h>
K8056Velleman Relay;
void setup()
{
Relay.begin(3);
for (int i = 0; i <= 8; i++) {Relay.ON(1,i);delay(500);}
Relay.OFF(1,4); delay(500);
Relay.EmergencyStop(); delay(500);
Relay.Toggle(1,3); delay(500);
Relay.Toggle(1,3); delay(500);
Relay.digitalWrite(1,9,HIGH); // Guztiak piztu.
delay(500);
Relay.digitalWrite(1,9,LOW); // Guztiak piztu.
}
void loop()
{
210
12P2: K8056. INFRAGORRIEN BIDEZ TXARTELA KONTROLATU
1. Helburuak
Helburua da Velleman K8056 errele-txartela infragorrien bidez kontrolatzea. 8

erreleak kontrolatuko dira urrutiko agintearekin. Kontrolatzeko, RS232
protokoloa erabiliko da.
Urrutiko agintearen botoiak sakatzean (1etik 8rako botoiak), aldatu egingo da

erreleen egoera (1etik 8rako erreleak). Botoien funtzionamendua hau izango
da:
Botoiak, 1etik 8ra: botoi bakoitzak 1etik 8ra dagokion errelea piztu edo
amatatuko du. Power botoiak errele guztiak piztuko ditu. Isildu botoiak eta 9.
botoiak errele guztiak itzaliko dituzte.
2. Prozedura
Programa kargatu, eta erreleak piztu eta amatatzeko egindako programaren

sekuentzia jarraituko dugu. Egiaztatu ezazu erabilitako komandoak egin
beharreko funtzioa betetzen dutela.
3. Materiala

- Velleman K8056 txartela
- VS1838B infragorrien hartzailea
- Urrutiko aginte bat (etxeko edozeinek balio du: Telebistakoak, adibidez)
211
Infragorrien eskema
VS1838B hartzailearen konexioak
Urrutiko zenbait aginte
212
5. Kodea
/*
Aurreko praktika erabiliko dugu, INFRAGORRIEN praktikarekin batera e
rreleak aktibatzeko.
Botoiak hauek izango dira:
1: 1.errelea piztuko edo amatatuko du
9: Errele guztiak piztuko ditu.
Power: Errele guztiak itzaliko ditu.
//kOMANDOAK
//Relay.begin(3);
//Relay.EmergencyStop(); // Errele guztiak itzaltzen ditu
//Relay.ON(1,9); // Errele guztiak pizten ditu
//Relay.OFF(1,9); // Errele guztiak itzaltzen ditu
//Relay.ON(1,4); // 4. errelea pizten du
//Relay.OFF(1,4); // 4. errelea itzaltzen du
//Relay.Toggle(1,3); // 3. errelearen egoera-balioak truk
atzen ditu
//Relay.digitalWrite(1,6,HIGH); // Relay.ON(1,6); bietako bat
//Relay.digitalWrite(1,6,LOW); // Relay.OFF(1,6); bietako bat
*/
#include <K8056Velleman.h>
#include “IRremote.h”
K8056Velleman Relay;
int igPIN = 2; // seinale infragorriak Arduinoaren

2. pinetik jasoko dira
IRrecv irrecv(igPIN); // ‘igPIN’etik kodea jasoko da
decode_results eskuratutakoKodea; // ‘eskuratutakoKodea’n kodea Hex.
void setup()
{
Serial.begin(9600);
Serial.println(“Infragorriak testeatzen!”);
Serial.println(“Erreleak piztu/amatatu itzazu!”);
Relay.begin(3);
Relay.EmergencyStop(); // Errele guztiak itzaltzen ditu
//K8056 txartela frogatu. Ezabatu kode lerro hau benetako programa

erabiliko baduzu:
for (int i = 0; i <= 8; i++) {Relay.ON(1,i); delay(500);}
213
void loop()
{
if (irrecv.decode(&eskuratutakoKodea)) // Jaso al da seinale
infragorririk?
{
translateIR(); // Sakatu den botoiaren esanahia serie-
monitoretik inprimatu
}
}
void translateIR() // Jasotako kode infragorriaren arabera, agindua

bete
{
{
case 0xFFA25D: Relay.ON(1,9); break; // ‘Power’: Dena piztu
case 0xFFE21D: Relay.OFF(1,9); break; // ‘Isildu’: Dena Itzali
case 0xFF30CF: Relay.Toggle(1,1); break; // ‘1’ botoia
case 0xFF18E7: Relay.Toggle(1,2); break; // ‘2’ botoia
case 0xFF7A85: Relay.Toggle(1,3); break; // ‘3’ botoia
case 0xFF10EF: Relay.Toggle(1,4); break; // ‘4’ botoia
case 0xFF38C7: Relay.Toggle(1,5); break; // ‘5’ botoia
case 0xFF5AA5: Relay.Toggle(1,6); break; // ‘6’ botoia
case 0xFF42BD: Relay.Toggle(1,7); break; // ‘7’ botoia
case 0xFF4AB5: Relay.Toggle(1,8); break; // ‘8’ botoia
case 0xFF52AD: Relay.OFF(1,9); break; // ‘9’: Dena Itzali
default: Serial.println(“ 22 other button “);
}
delay(500);
}
214
13. BLOKEA:
MOSFET.
IRTEERA DIGITALEN BALIOA EGOKITU
215
13. BLOKEA: MOSFET. IRTEERA DIGITALEN BALIOA
EGOKITU
Helburua
Arduinoen irteerak 5 V-koak dira eta potentzia gutxikoak. Tentsio handiagoa

edo korrontearen intentsitate handiagoa behar denean, azken finean, potentzia
handiagoa behar denean, arduinoaren irteeran MOSFET bat konektatu daiteke
tentsioa edota korrontearen intentsitatearen balio horiek egokitzeko.
- Arduinoari MOSFET bat konektatzen

- Konexioak egiten tentsioa egokitzeko edo korrontearen intentsitatea
egokitzeko.
13P1: N KANALEKO MOSFET “LOGIC LEVEL” BAT ERABILI

13P2: N KANALEKO MOSFET ARRUNT BAT ERABILI
13P3: P KANALEKO MOSFET ARRUNT BAT ERABILI
216
ARDUINOAREN IRTEERA DIGITAL BAT EGOKITU, BESTE TENTSIO BAT
ETA BESTE POTENTZIA BAT IZATEKO
Potentziako MOSFET bat arduinora konektatzen ikasiko da. Horrekin, motoreak

edo potentzia handia behar duten osagaiak elikatu daitezke (behe tentsioko
korronte zuzenean).
Potentziako MOSFETak osagai elektronikoak dira, eta korrontearen intentsitate

handiak kontrolatu ditzakete. MOSFETek hiru terminal dituzte: Drain, Source
eta Gate. Korrontearen Intentsitatea Sourcetik Drainera pasatzen da (ISD) eta
intentsitate hori kontrolatzen du Gaten eta Sourceren artean dagoen tentsio
erorketaren bidez, VGS .
MOSFET batek Arduinora edo mikrokontrolatzaile batera duen konexioa
MOSFET batek ez du kontsumorik, salbu kommutatzen denean. Egoera

egonkor batean ez du kontsumorik.
Bi motatako potentziako MOSFETak daude: N kanalekoak eta P kanalekoak.

Horien arteko desberdintasuna Sourceren eta Drainen polaritatean datza eta
sarrerako tentsioan:
217
MOSF SATURATUTA EBAKITA
ET
N VGS > Vth eta VDS > ( VGS – VGS < Vth
Vth)
P VGS > Vth eta VDS < ( VGS – VGS < Vth
Vth)
N kanaleko MOSFETa P kanaleko MOSFETa
Potentziako MOSFETek balio digitalekin eta balio analogikoekin egin dezakete

lan.
Balio analogikoekin lan egiten dutenean, “lineako eremuan” edo “saturatutako

eremuan” egiten dute lan, audio anplifikadore baten seinalea anplifikatzeko
adibidez.
Balio digitalekin lan egiten dutenean , “saturatutako eremuan: ON” eta “moztuta
eremuan: OFF” egiten dute lan, hau da, MOSFETak etengailu bat balitz bezala
egiten du lan: irekita edo itxita.
Praktika honetan, MOSFETak etengailu eran aztertuko dira.
MOSFET bat saturatuta dagoenean, Sourceren eta Drainen arteko

erresistentzia (Rsd) oso txikia da. Horregatik, MOSFETak kontsumitzen duen
potentzia oso txikia da eta korronte handiak garraiatu ditzake.
218
.
MOSFET bat potentzia-etengailu gisa erabilita
MOSFET bat saturatzeko, Gate terminalean dagoen tentsioa balio jakin batera
heldu behar da, VGS > Vth. Arduinoa 5 volteko tentsiora heldu daiteke, eta,
MOSFETaren arabera, tentsio hori nahikoa izan daiteke MOSFETa
saturatzeko, edo ez. Potentziako MOSFET batean, gerta daiteke V th > 5v izatea.
Gainera, MOSFETak, saturaziora heltzen ez bada eta lineako eremuan
geratzen bada, potentzia handia xurgatuko du: Pmosfet = Vsd * Isd.
Irudi honetan ikusten da MOSFETa saturatzeko 5.5V < V GS < 7.5V bete behar
dela, eta arduinoarekin ez da nahikoa 5 volt baitu:
219
MOSFET baten kurbak VGS eta IDS balio desberdinen arabera. Lineako eta saturazioko eremuak
Grafikoan ikusten da N kanaleko MOSFET batek, 30A eskatzen zaizkionean,

VGS = 7.5V-ekoa izan behar duela. 10A eskatzen zaizkionean, ordea, V GS =
5.5V-ekoa izan behar du, eta kasu horretan, beraz, ARDUINOAK EZ DU
MOSFETa SATURATUKO.
Arazo hori gainditzeko, bi aukera daude: Arduinoaren irteeran dagoen balioa

egokitu osagai gehiagorekin, edo V GS txikiagoak erabiltzen dituen MOSFET bat
lortu: maila logikoetara egokitutako potentziako MOSFET bat (logic level power
MOSFET), adibidez.
Grafiko honetan, urdinez, IRF530 potentziako MOSFET arrunt baten kurba

daukagu. Berdez, berriz, IR L530 maila logikoetara egokitutako potentziako
MOSFET batena. Konparatzen baditugu eta bakoitzari 30A eskatzen badiogu,
IRL530a 4,75V-ekin saturatuko da. Bestea, IRF530a, 4,75 V-ekin saturatzetik
urrun dago:
220
MOSFET “Logic level” baten eta arrunt baten arteko konparazioa
221
13P1: N KANALEKO MOSFET “LOGIC LEVEL” BAT ERABILI
MOSFET “Logic level” baten konexio zuzena
Arduinoarekin edo mikrokontrolatzaile batekin lan egiten denean, aukerarik

onena MOSFET “logic level” bat aukeratzea da. Irudian, kontsumo handiko LED
tira bat pizteko erabili den konexioa ageri da. Erreparatu LEDak elikatzeko
tentsioa (12V) arduinoaren tentsioa (5V) baino handiagoa dela.
MOSFET batek kontrolaren maila logikoa aldatzen duenean, MOSFETAK

korronte bat xurgatuko du barruan duen kondentsadoreagatik.
Kondentsadorearen hasierako korronte hori mugatzeko, 4K7-ko erresistentzia
erabiliko da. MOSFETaren kommutazio-maiztasunaren arabera, erresistentzia
horren balioa aldatu egin daiteke: Gogoratu 5RC izango dela kondentsadoreak
kargatzeko beharko duen denbora.
Beraz, MOSFETa erabiltzen bada:
- Maiztasun handiekin, PWM erregulazio bat egiteko adibidez, 1 kΩ-4K7

tarteko erresistentzia konektatuko da.
- Maiztasun txikiekin, LED tira bat pizteko adibidez, 10 kΩ-eko
erresistentzia konektatuko da.
Masara konektatuta dagoen 100 kΩ-eko erresistentziak egoera logiko bat

finkatuko du arduinoak balio logiko zehatzik ematen ez duenean, adibidez,
arduinoa hasieratzen dagoenean.
222
13P2: N KANALEKO MOSFET ARRUNT BAT ERABILI
“Logic level” ez den MOSFET bat erabiltzen badugu, arduinoaren irteera

(MOSFETaren sarrera) egokitu behar dugu tentsioa 5V baino handiagoa izan
dadin. Tentsio hori igotzeko, transistore bat gehituko da arduinoaren irteeran
irudi honetan ikusten den moduan:
N kanaleko MOSFET arrunt baten sarrerako tentsioa egokitzea
Funtzionamendua hau da:
Arduinoak irteeran 0 volt dituenean, transistoreak ez du korronterik garraiatuko.

Hori dela eta, kolektoreak, MOSFETaren Gate-ra konektatuta, 12 volteko
tentsioa emango dio erresistentziaren bidez, eta MOSFETa saturatuko du
(itxita). Gogoratu saturatzeko VGS > Vth eta VDS > (VGS – Vth) baldintzak bete
behar direla.
Arduinoak irteeran 5 volt dituenean, transistoreak korrontea garraiatuko du; hori

dela eta, kolektoreak, MOSFETaren Gate-ra konektatuta, 0 volteko tentsioa
emango dio GND bidez, eta MOSFETa moztuko du (irekita).
Zirkuitu horrek logika inbertsoa erabiltzen du. Hau da, arduinoak irteeran balio
positiboa duenean, MOSFETa irekita dago, eta arduinoak irteeran balio
negatiboa duenean, MOSFETa itxita dago. Abantaila bat du: etapa horrekin
edozein MOSFET saturatu ahal izatea bermatzen da, etapa elikatzeko tentsioa
egokituta.
223
13P3: P KANALEKO MOSFET ARRUNT BAT ERABILI
MOSFETa kontrolatzeko, logika inbertsoa erabili beharrean, logika zuzena

erabili nahi badugu, P kanaleko MOSFET bat erabili behar da.
Funtzionamendua hau da:
Arduinoak irteeran 0 volt dituenean, transistoreak ez du korronterik garraiatuko;

hori dela eta, kolektoreak, MOSFETaren Gatera konektatuta, 12 volteko
tentsioa emango dio erresistentziaren bidez, eta MOSFETa moztuko du
(irekita). Gogoratu, mozteko VGS < Vth bete behar dela, eta saturatzeko, VGS >
Vth eta VDS < (VGS – Vth) bete behar dela.
Arduinoak irteeran 5 volt dituenean, transistoreak korrontea garraiatuko du; hori

dela eta, kolektoreak, MOSFETaren Gate-ra konektatuta, 0 volteko tentsioa
emango dio GND bidez, eta MOSFETa moztuko du (irekita).
P kanaleko MOSFET arrunt baten sarrerako tentsioa egokitzea
224
14. BLOKEA:
DATUAK GORDE SD TXARTEL BATEAN
225
14. BLOKEA: DATUAK GORDE SD TXARTEL BATEAN
Helburua
Helburua da datuak SD txartel batean gordetzea.
Datu horiek, tenperatura, hezetasuna, edo sarrera/irteera digitalen egoera

izango dira, adibidez.

- Arduinoari SD modulu bat konektatzen
- SD txartel bat nola testeatu, nola irakurri eta nola idatzi ikasten
- Sarreren balioak SD txartelan gordetzen
14P1: SD. TESTEATU

14P2: SD. DATUAK IRAKURRI ETA IDATZI
14P3: SD. FITXATEGIAK SORTU ETA EZABATU
14P4: SD.SD TXARTELEAN ZER FITXATEGI DAUDEN ERAKUTSI
14P5: SD. SARRERA ANALOGIKOEN BALIOA GORDE
226
KONEXIOAK
ETHERNET SHIELD plaka, arduinoaren gainean muntatuko da.
Gogoratu arduinoak ETHERNET SHIELD plakarekin komunikatzeko 10, 11, 12,

eta 13 pin digitalak erabiltzen dituela. Pin horiek, SHIELD hau erabilita, ezin
daitezke Sarrera/Irteera digital moduan erabili.
Konexioa, Ethenet shield bada, ez da konexiorik egin behar, bakarrik txartela

gainean muntatu. SD modulu bat bada, egin behar diren konexioak hauek dira:
ETHERNET ADAFRUIT SD SPARKFUN SD

SHIELD SHIELD SHIELD
MOSI 11 11 11
MISO 12 12 12
CLK 13 13 13
CS 4 10 8
227
PRAKTIKAK
Praktika hauetan, txartelaren konexioa, prozedura eta behar den materiala

errepikatu egingo dira. Praktika hauetan, praktikaren helburua azalduko da,
kodea jarriko da eta serie-monitoretik bistaratzen dena erakutsiko da.
9. Prozedura
Konexioak egin, SD txartel bat sartu, kodea kargatu, serie-monitorea ireki eta
bistaratzen diren datuak egokiak diren konprobatu.
Kode osoa irakurri.
10. Materiala

- SD txartel bat
11. Konexioak
ETHERNET ADAFRUIT SD SPARKFUN SD

SHIELD SHIELD SHIELD
MOSI 11 11 11
MISO 12 12 12
CLK 13 13 13
CS 4 10 8
228
14P1: SD. TESTEATU
1. Helburuak
Praktika honen helburua SD txartel bat testeatzea da. Txartelaren ezaugarriak

serie-monitorean bistaratuko dira.
2. Kodea
/*
SD txartela TESTEATU
Programa honekin SD txartela bat frogatuko da.
SD txartelaren ezaugarriak hartuko dira.
Programa hau SD txartel batek funtzionatzen duen edo ez egiaztat
zeko erabili dezakezu
Konexioak hauek dira:
MOSI - pin 11
MISO - pin 12
CLK - pin 13
CS - pin 4
ETHERNET SHIELD batekin ez da konexiorik egin behar.
*/
#include <SD.h>
// set up variables using the SD utility library functions:
Sd2Card card;
SdVolume volume;
SdFile root;
// aldatu hau SD shield edo modulu bat erabiliko baduzu;
// Arduino Ethernet shield: pin 4
// Adafruit SD shields eta moduluak: pin 10
// Sparkfun SD shield: pin 8
const int chipSelect = 4;
void setup()
{
Serial.begin(9600);
while (!Serial) {
; // itxaron serie-portuari konexioa egiteko. Bakarrik
Leonardorako}
}
Serial.print("SD txartela hasieratzen...");

// Ethernet Shield txartelean, CS 4 pina da. Hori automatikoki
OUTPUT bat izango da.
// SS pina output bezala konfiguratuko da. (10 Arduino txartel
gehienetan, 53 Mega txartelean)
229
// Txartela dabilen testeatuko dugu:

if (!card.init(SPI_HALF_SPEED, chipSelect)) {
Serial.println("Hasieratzeak kale egin du. Hurrengoa
egiaztatu::");
Serial.println("*Sartu duzu txartela? Ondo sartuta dago?");
Serial.println("*Ondo dago kableatuta?");
Serial.println("*Aukeratu duzu zure shield-ari edo moduluari
dagokion chipSelect pin egokia?");
return;
} else {
Serial.println("Txartela topatu da eta ondo kableatuta
dago.");
}
// print the type of card

Serial.print("\nTxartela mota: ");
switch(card.type()) {
case SD_CARD_TYPE_SD1:
Serial.println("SD1");
break;
case SD_CARD_TYPE_SD2:
Serial.println("SD2");
break;
case SD_CARD_TYPE_SDHC:
Serial.println("SDHC");
break;
default:
Serial.println("Unknown");
}
// Now we will try to open the 'volume'/'partition' - it

should be FAT16 or FAT32
if (!volume.init(card)) {
Serial.println("Could not find FAT16/FAT32 partition.\nMake
sure you've formatted the card");
return;
}
// print the type and size of the first FAT-type volume
uint32_t volumesize;
Serial.print("\nVolume type is FAT");
Serial.println(volume.fatType(), DEC);
Serial.println();
volumesize = volume.blocksPerCluster(); // clusters are

collections of blocks
volumesize *= volume.clusterCount(); // we'll have a lot
of clusters
volumesize *= 512; // SD card
blocks are always 512 bytes
Serial.print("Volume size (bytes): ");
Serial.println(volumesize);
230
Serial.print("Volume size (Kbytes): ");
volumesize /= 1024;
Serial.print("Volume size (Mbytes): ");
volumesize /= 1024;
Serial.println("\nFiles found on the card (name, date and size

in bytes): ");
root.openRoot(volume);
// list all files in the card with date and size
root.ls(LS_R | LS_DATE | LS_SIZE);
}
void loop(void) {
}
3. Serie-monitorean bistaratzen diren datuak
231
14P2: SD. DATUAK IRAKURRI ETA IDATZI
1. Helburuak
Praktika honen helburua SD txartel batean datuak idaztea eta irakurtzea da.
2. Kodea
/*
SD txartela irakurri/idatzi
Programa honekin SD txartel batean irakurri eta idatziko da.
MOSI - pin 11
MISO - pin 12
CLK - pin 13
CS - pin 4
*/
#include <SD.h>
File nireFitxategia;
void setup()
{
Serial.begin(9600);
while (!Serial) {
Leonardorako}
}

// SS pina output bezala konfiguratuko da. (10 Arduino
txartela gehienetan, 53 Mega txartelean)
if (!SD.begin(4)) {
Serial.println(" SD txartela EZ da hasieratu!");
return;
}
Serial.println(" SD txartela hasieratu da!");
// Fitxategia ireki. Fitxategi bakarra ireki daiteke aldiko.

nireFitxategia = SD.open("testua.txt", FILE_WRITE);
// fitxategia ondo ireki bada, idatzi bertan:

if (nireFitxategia) {
Serial.print("Idazten testua.txt fitxategian...");
nireFitxategia.println("Idazten 1, 2, 3.");
232
// fitxategia ixten:
nireFitxategia.close();
Serial.println(" eginda!");
} else {
// fitxategia ireki ez bada, errorea dagoela abisatu:
Serial.println(" errorea testua.txt irekitzen!");
}
// ireki fitxategia irakurtzeko:

nireFitxategia = SD.open("testua.txt");
Serial.println("testua.txt fitxategian idazten:");
// irakurri fitxategiko datu guztiak:

while (nireFitxategia.available()) {
Serial.write(nireFitxategia.read());
}
// fitxategia itxi:
} else {
// fitxategia ireki ez bada, errorea dagoela abisatu:
Serial.println(" errorea testua.txt irekitzen!");
}
}
void loop()
{
233
14P3: SD. FITXATEGIAK SORTU ETA EZABATU
1. Helburuak
Praktika honen helburua SD txartel batean fitxategiak sortzea eta idaztea da.
2. Kodea
/*
SD txartelean fitxategi bat sortu eta ezabatu
MOSI - pin 11
MISO - pin 12
CLK - pin 13
CS - pin 4
*/
#include <SD.h>
File nireFitxategia;
void setup()
{
Serial.begin(9600);
while (!Serial) {
Leonardorako}
}

// Ethernet Shield txartelean, CS 4 pina da. Hori
automatikoki OUTPUT bat izango da.
if (!SD.begin(4)) {
return;
}
if (SD.exists("adibidea.txt"))
{Serial.println("adibidea.txt fitxategia badago!");}
else {Serial.println("adibidea.txt fitxategia ez
234
dago!");}
// Sortu fitxategi bat eta jarraian ezabatu:

Serial.println("adibidea.txt fitxategia sortzen...");
nireFitxategia = SD.open("adibidea.txt", FILE_WRITE);
// Konprobatu fitxategia existitzen den:

{Serial.println("adibidea.txt fitxategia badago!");}
else {Serial.println("adibidea.txt fitxategia ez
dago!");}
// Fitxategia ezabatu:

Serial.println("adibidea.txt fitxategia ezabatzen...");
SD.remove("adibidea.txt");
{Serial.println("adibidea.txt fitxategia badago");}
else {Serial.println("adibidea.txt fitxategia ez dago");}
}
void loop()
{
235
14P4: SD. DAUDEN FITXATEGIAK ERAKUTSI
1. Helburuak
Praktika honen helburua SD txartel batean dauden fitxategiak erakustea da.
2. Kodea
/*
SD txartelean fitxategi bat sortu eta ezabatu
MOSI - pin 11
MISO - pin 12
CLK - pin 13
CS - pin 4
*/
#include <SD.h>
File root;
void setup()
{
Serial.begin(9600);
while (!Serial) {
Leonardorako}
}

// SS pina output bezala konfiguratuko da. (10 Arduino txartela
gehienetan, 53 Mega txartelan)
if (!SD.begin(4)) {
return;
}
root = SD.open("/");
printDirectory(root, 0);
Serial.println("eginda!");
}
void loop()
{
}
void printDirectory(File dir, int numTabs) {
236
while(true) {
File entry = dir.openNextFile();

if (! entry) {
// irakurtzeko fitxategiak badaude jarraitu; bestela, ez.
break;
}
for (uint8_t i=0; i<numTabs; i++) {
Serial.print('\t');
}
Serial.print(entry.name());
if (entry.isDirectory()) {
Serial.println("/");
printDirectory(entry, numTabs+1);
} else {
// fitxategien tamaina erakutsi. Direktorioena, ez.
Serial.print("\t\t");
Serial.println(entry.size(), DEC);
}
entry.close();
}
}
237
238
14P5: SD. SARRERA ANALOGIKOEN BALIOAK GORDE
1. Helburuak
Praktika honen helburua da hiru sentsore analogikoren balioak SD txartel

batean gordetzea. Hiru segundoero irakurketa bat egingo da.
2. Kodea
/*
SD txartelean hiru sentsore analogikoren balioak idatziko d
ira
MOSI - pin 11
MISO - pin 12
CLK - pin 13
CS - pin 4
*/
#include <SD.h>
const int chipSelect = 4;
void setup()
{
Serial.begin(9600);
while (!Serial) {
Leonardorako
}

// Ethernet Shield txartelean, CS 4 pina da. Hori
automatikoki OUTPUT bat izango da.
if (!SD.begin(chipSelect)) {
return;
}
Serial.println("Hiru sentsoreen balioa irakurtzen:");
}
239
void loop()
{
// string bat sortu informazioa gordetzeko:
String datuKatea = "";
// Hiru sentsoreak irakurri eta stingean idatzi:

for (int analogPin = 0; analogPin < 3; analogPin++) {
int sentsorea = analogRead(analogPin);
datuKatea += String(sentsorea);
if (analogPin < 2) {
datuKatea += " ,";
}
}
// gogoratu irekita fitxategi bakarra egon daitekeela,

// itxi besteak hau ireki baino lehen:
File nireFitxategia = SD.open("datuak.txt", FILE_WRITE);
// fitxategia badago, idatzi:

nireFitxategia.print("A0, A1, A2 = ");
nireFitxategia.println(datuKatea);
// serie-portuan ere inprimatuko dugu:
Serial.print("A0, A1, A2 = ");
Serial.println(datuKatea);
}
// fitxategia ireki ez bada, abisatu errorea dagoela:
else {
Serial.println("errorea datuak.txt irekitzen!");
}
delay (3000);
}
240
241

Arduino. Praktika Bilduma

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Arduino. Praktika Bilduma

Uploaded by

Copyright:

Available Formats

ARDUINOA

2. Arduino plataforma instalatzea................................................8

3. Arduino txartel bat martxan jartzea..........................................9

P1.1: FRITZINGa. Lehenengo muntaia diseinatzea

5. Arduinoarekin sortutako kodigoa testu-dokumentu batera

2. Blokea: sarrera eta irteera digitalak...................................................42

3. Blokea: sarrera eta irteera analogikoak.............................................52

8. Blokea: Ethernet bidez arduinoa kontrolatu...................................116

9. Blokea: Internet bidez arduinoa kontrolatu.....................................131

10. Blokea: app bat sortu arduinoa kontrolatzeko.............................149

11. Blokea: Bluetooth-a.........................................................................170

12P1: K8056. Txartela testeatu

13. Blokea: MOSFET. Irteeren tentsio balioa egokitu.........................200

13P1: N kanaleko MOSFET “LOGIC LEVEL” bat erabili

14. Blokea: datuak gorde SD txartel batean........................................209

14P1: SDa. Testeatu

Zer ezagutza maila behar dut proiektuak egiteko

Zer topatuko duzu liburu honetan

Norentzat da liburu hau

Horretaz gain, garrantzitsua da jakitea serie-monitoreak nola

Open-hardware-a librea da, eta ondorioz, ez da lizentziarik erosi edo egile-

Gainera, erabiltzen erraza eta ekoizteko merkea denez, gomendagarria da

2.1. Programa jaitsi

2.2. Programa instalatu

3.1. Txartela konektatu eta kontroladorea instalatu

Arduino UNO txartela USB konexio-kablea

Konexioa egitean, Windows sistema-eragileak esan du ezin dela kontroladorea

Windowsek ez du kontroladorea instalatuko. Eskuz egin beharra dago

1 kontrol-panela / Sistema eta segurtasuna / Sistema / Gailu-kudeatzailea

3 Arduinoaren karpetara joan eta drivers karpetan sartu

Hori eginda, txartela instalatuta dago, eta funtzionatzen hasteko gutxieneko

Programa abiatzen denean, konfigurazio bi egingo dira:

1 Zer txartel konektatu den esan behar zaio programari:

Lehenengo, programa kargatu

4.1. Zer da FRITZNGa?

Arduinorekin muntatuko diren eskema elektrikoak marrazteko balio duen

Hona hemen Arduinorekin egin daitezkeen zenbait adibide. Era honetako

Fritzinga Processing-en eta Arduinoren printzipioetan oinarrituta dago. Arduinon

4.3. Fritzing instalatu

Fritzing instalatzeko, http://fritzing.org/download/ web-orrialdean sartu eta

4.4. Diseinuak egiteko erremintak

Programa ireki eta eskemak sortzeko hiru erreminta daude:

Protoboard baten gainean, eskemak egin daitezke. Protoboardean arduinoa,

Azkeneko modu honek aukera ematen digu zirkuitu elektrikoa eta

4.5. Diseinuak ekoiztea

Egindako diseinua fabrikatzeak zer prezio duen ere ikusi daiteke:

Praktika gidaliburu honetan agertzen diren muntaiak, eskema elektrikoak, eta

FRITZING programak Arduinon oinarritutako prototipoak dokumentatzeko balio

Kapitulu honetan hau ikasiko da:

- Muntaiak protoboard baten gainean diseinatzen

Kapitulu honetan praktika hauek egingo dira:

P1.1: FRITZINGa. Lehenengo muntaia diseinatzea

P1.2: FRITZINGa. Lehenengo eskema diseinatzea

P1.3: FRITZINGa. Lehenengo PCBa diseinatzea

P2: FRITZINGa. Bigarren PCBa diseinatzea

P3: FRITZINGa. Bigarren muntaia bat diseinatzea

Sarrera digital bat konektatuko da pultsadore batekin eta pull-down

A0 sarrera analogikoan potentziometro bat konektatuko da.

Osagai txikiak, erresistentziak eta ledak protoboardaren gainean kokatuko

Gogoratu, elektronikako beste edozein programatan bezala, komandoak erabili

Horrek erraztu egingo du kableak konektatzea. Hurrengo pausoa kableak

Aurreko praktikan, zirkuitu bat muntatu dugu protoboard baten gainean.

Oraingoan, praktika beraren eskema elektrikoa egingo dugu.