OK Mégsem
Fórum témák

» Több friss téma
Cikkek » Launchpad: ismerkedés az MSP430 mikrovezérlőkkel II.
Launchpad: ismerkedés az MSP430 mikrovezérlőkkel II.
Szerző: icserny, idő: Nov 3, 2011, Olvasva: 22764, Oldal olvasási idő: kb. 11 perc
Lapozás: OK   7 / 8

Timer - a sokoldalúan használható időzítő

Az MSP430 mikrovezérlők sokoldalúan használható időzítője a Timer modul. Az első részben bemutatott MSP430G2231 mikrovezérlő blokkvázlatot érdemes újra felidézni! Az alábbi ábrán a színezéssel megjelölt modul TIMER0_A2 azt jelenti, hogy az első (és egyetlen) Timer egység "A" típusú, s 2 db. Capture/Compare csatorna csatlakozik hozzá.

7_1. ábra: Az MSP430G2231 mikrovezérlő blokkvázlata

Minden MSP430 mikrovezérlő tartalmaz legalább egy TIMER_A modult, a nagyobb kiépítettségűek esetleg többet is, s ezek sorszámozása 0-val kezdődik.  TIMER B típusú modul az MSP430G2xxx család eddigi tagjainál nem fordul elő, az MSP430Fxxx típusoknál találkozhatunk vele.

Timer_A felépítése

A TIMER_A modul leegyszerűsített blokkvázlata az alábbi ábrán látható. Hardveresen két fő részre osztható: a számláló egységre (Timer blokk) és a jelelfogásra, digitális komparálásra vagy impulzusszélesség-modulációra használható Capture/Compare csatornákra. A Launchpadhoz kapott mikrovezérlőink Timer_A modulja két Capture/Compare csatornával rendelkezik, melyek közül csak a másodikat (az 1. sorszámmal rendelkezőt) tüntettük fel. Az első (0. sorszámú) csatornával kapcsolatban csak az EQU0 belső jel becsatlakozását tüntettük fel. Megjegyezzük, hogy a nagyobb kiépítettségű MSP430G2452  vagy MSP430G2553 mikrovezérlők Timer_A moduljainak három Capture/Compare csatornája van, tehát ezeknél 0-tól 2-ig terjed a sorszámozás.

7_2. ábra: A TIMER_A egység egyszerűsített blokkvázlata

A számláló

A számláló egység (Timer blokk) egy 16 bites regisztert tartalmaz (TAR), amelyhez a következő források közül választhatunk:

  • külső órajel: TACLK vagy INCLK. A Launchpadhoz kapott mikrovezérlőknél mindkettő a P1.0 bemenetet jelenti (nincs külön kivezetés INCLK számára), de TACLK választása esetén felfutó, INCLK esetén pedig lefutó élre történik a számlálás.
  • az ACLK órajel, ami általában 32 kHz vagy (VLO használata esetén) 12 kHz
  • az SMCLK órajel, ami általában magas frekvenciájú (MHz-es nagyságrendű)

A bejövő órajel szükség esetén tovább osztható 2-vel, 4-gyel, vagy 8-cal. A számláló túlcsordulásakor (amikor TAR 0xFFFF-ből 0-ra vált) a TAIFG jelzőbit bebillen, s engedélyezése esetén programmegszakítást generál (a TIMERA0_VECTOR tartozik hozzá). A számláló üzemmódja az MCx bitcsoporttal állítható be az alábbiak szerint:

00 - A Timer blokk letiltva, TAR nem számol. Bekapcsoláskor ez az alapértelmezett beállás.

01 - Felfelé számlálás adott értékig. A számláló 0-tól a TACCR0 regiszterben megadott értékig számol, majd nullázódik és újra kezdi a számolást. A periódus tehát TACCR0 + 1 lesz. Például TACCR = 4 esetén a számláló sorban a következő értékeket veszi fel: 0, 1, 2, 3, 4, 0, 1, 2, ... stb. A periódus itt 5. Ez a módot használjuk adott frekvenciájú jel (vagy megszakítás) keltéséhet, vagy impulzusszélesség-modulációhoz (PWM).

10 - Folyamatos számlálás. A számláló 0-tól 0xFFFF-ig számol, túlcsorduláskor bebillenti a TAIFG jelzőbitet.

11 - Fel/le számlálás, adott értékig. A számláló 0-tól a TACCR0 regiszterben megadott értékig számol, majd onnan visszafelé, a nulláig. Nullától újra kezdi a számolást. A periódus tehát 2 x TACCR0 lesz. Például TACCR = 3 esetén a számláló sorban a következő értékeket veszi fel: 0, 1, 2, 3, 2, 1, 0, ... stb. A periódus itt 6. Ez egy elég speciális üzemmód, főleg akkor használjuk, ha középpontba állított PWM jelet akarunk előállítani.

A Capture/Compare csatornák

A CCR0 és CCR1 bemeneti jelelfogás (input capture), valamint a TA0 és TA1 digitális összehasonlítók (compare) azonos felépítésűek, ezért a fenti blokkvázlaton csak az egyiket tüntettük fel. A Capture/Compare csatornák központi eleme a 16 bites TACCRx regiszter, amelybe jelelfogás módban a kiválasztott esemény bekövetkeztekor átmásolódik a TAR regiszter pillanatnyi állapota, komparátor módban pedig megadja azt az időt, amelyet elérve a kimenet változik, s programmegszakítási kérelem keletkezik.

A Timer_A egység regiszterei

A TIMER_A egység a következő regisztereket használja:

Regiszter
 Funkció rövid leírása Cím Típus
TACTL TIMER_A vezérlő regisztere 0x160 r/w
TAR TIMER_A számláló regisztere 0x170 r/w
TACCTL0 Capture/Compare 0. csatorna vezérlő regisztere 0x162 r/w
TACCR0 Capture/Compare 0. csatorna adatregisztere 0x172 r/w
TACCTL1 Capture/Compare 1. csatorna vezérlő regisztere 0x164 r/w
TACCR0 Capture/Compare 1. csatorna adatregisztere 0x174 r/w
TAIV TIMER_A interrupt vektor 0x12E ro

Ezek közül a TAR,TACCR0 és TACCR1 szerepéről már szó volt. TACTL a számlálóegység (Timer blokk) vezérlő regisztere, TACCTL0 és TACCTL1 a két Capture/Compare csatorna vezérlő regiszterei, TAIV pedig a TIMERA1_VECTOR-hoz tartozó megszakítás esetén a megszakítást okozó, legmagasabb prioritású esemény azonosítóját tartalmazza.

A TACTL regiszter

A Timer blokk vezérlő regiszterének segítségével ki lehet választani a számláló jelforrását és a bementi osztó osztási arányát, s be lehet állítani a számláló üzemmódját (folyamatos, felfelé számlálás adott értékig, le/fel számlálás adott értékig). Ugyanitt kaptak helyet a számláló blokk megszakításengedélyező és megszakítást jelző bitjei is.

A TACTL regiszter 16 bites, de nincs mindegyik bitje kiépítve/felhasználva. Az alábbi ábrán a nem használt biteket szürke satírozás jelzi. A bitek neve fölött feltüntettük a bit sorszámát, alatta pedig az alapértelmezett beállást, valamint az írható/olvasható tulajdonságot.

A bitek ismertetésénél az alábbiakban az angol megnevezést is megadjuk, így talán könnyebb lesz megjegyezni a belőlük képzett rövidítéseket.

TASSELx - jelforrás kiválasztás (Timer_A source select). Ezzel a bitcsoporttal választhatjuk ki a bemenő órajel forrását (00: TACLK, 01: ACLK ,10: SMCLK, 11: INCLK)

IDx - bemeneti oszó (input divider) beállítása (00: 1/1, 01: 1/2, 10: 1/4, 11: 1/8)

MCx - üzemmód vezérlés (mode control). Ez a bitcsoport a számláló üzemmódját állítja be (00: letiltva, TAR nem számol, 01: felfelé számlálás adott értékig, 10: folyamatos számlálás, 11: le/fel számlálás, adott értékig). Megjegyzés: Az adott értékig számláló üzemmódok a TACCR0 regisztert is használják!

TACLR - Timer_A törlés (Timer_a clear). Ha ebbe a bitbe '1'-et írunk, akkor törlődik Timer_A számlálója (TAR), s vele együtt nullázzuk a bemeneti osztó számlálóját is.

TAIE - Timer_A megszakítás engedélyezése (interrupt enable). Ezzel a bittel a számláló túlcsordulásakor bekövetkező megszakításokat lehet engedélyezni. A megszakítás a TIMERA1_VECTOR-ban megadott címre ugrik. Ez a vektor megosztott használatú, ezért a megszakítás kiszolgáláskor törölnünk kell a TAIFG jelzőbitet.

TAIFG - Timer_A megszakítás jelzőbit (interrupt flag). Ez a bit hardveresen billen '1'-be, amikor a számláló regiszter (TAR) túlcsordul, azaz 0xFFFF-rők 0x0000-ra vált.

A TACCTL0 és TACCTL1 regiszterek

A Capture/Compare csatornák vezérlő regiszterei egyformák, ezért csak egyszer írjuk le a tudnivalókat. Mindkettő 16 bites, melyek közül 15 bitjük van kiépítve/felhasználva. Az alábbi ábrán a nem használt biteket szürke satírozás jelzi. A bitek neve fölött feltüntettük a bit sorszámát. Az SCCI és CCI bitek csak olvashatók, a többi írható/olvasható. Bekapcsoláskor mindegyik bit '0' értéket kap.

Az egyes bitek szerepe a következő:

CMx - Capture Mode. Ez a bit állítja be a bemeneti jelelfogás üzemmódokat (00: nincs jelelfogás, 01: jelelfogás a felfutó élnél, 10: jelelfogás a lefutó élnél, 11: jelelfogás mind felfutó, mind a lefutó élnél)

CCISx Capture/compare bemenet választás (input select). Ezekkel a bitekkel választhatjuk ki a TACCRx regiszer bemenőjelét. (00: CCIxA, 01: CCIxB, 10: GND, 11: VCC)

SCS - A jelelfogás bemenőjelének szinronizálása (Synchronize capture source). Ez a bit választja ki, hogy szinkronizáljuk-e a jelelfogásnál a bejövő jelet a timer órajeléhez (0: nincs szinkronizálás, 1: szinkronizált capture)

SCCI - Szinkronizált capture/compare bemenet (Synchronized capture/compare input). A kiválasztott CCI bemenet jelét az EQUx jel szinkronizálja és rögzíti, s az eredmény ezen a biten kiolvasható.

CAP - Capture/Compare  üzemmód választás (0: Compare mód, 1? Capture mód)

OUTMODx - Kimeneti mód beállítása (Output mode). Nem mindegyik mód használható TACCR0-hoz! (000: az OUT jel szabja meg a kimenet állapotát, 001: beállítás, 010: átbillentés/reset, 011: beállítás/reset, 100: átbillentés
101: reset, 110: átbillentés/beállítás, 111: reset/beállítás)

CCIE - Capture/compare megszakítás engedélyezése (interrupt enable). Ezzel a bittel engedélyezhetjük, hogy a CCIFG bit megszakítást okozzon (0: Interrupt tiltás, 1: Interrupt engedélyezés).

CCI  - a  Capture/compare bemenet. A kiválasztott bemenőjel pillanatnyi állapota ezen a biten kiolvasható.

OUT -  A 0. kimeneti módban ez a jel közvetlenül a kimenetet vezérli (0: kimenőjel alacsony, 1: kimenőjel magas)

COV - Capture túlcsordulás (capture overflow). Ez a bit jelzi, ha bemeneti jelelfogáskor túlcsordulás történik. A bebillent jelzőbitet szoftveresen törölni kell (0: Nem történt túlcsordulás a capture módban, 1: túlcsordulás történt)

CCIFG - A Capture/compare csatorna megszakításjelző bitje (0: nincs megszakítási kérelem, 1: megszakítás van függőben)

Timer túlcsordulás figyelése lekérdezéssel

A Timer használatának legegyszerűbb módja az, ha folyamatos módban engedjük számlálni a számlálót, s figyeljük a túlcsordulásokat. Az alábbi programban LED1-et és LED2-t ellenütemben villogtatjuk,  kb. 1 s periódussal. Az időzítést a Timer túcsordulása (TAIFG bebillenése) adja. A programban az alapértelmezett 1 MHz körüli DCO frekvenciát használjuk. A Timer bemenőjele SMCLK lesz (TASSELx = 2), melyet 8-cal leosztunk (IDx = 3). A túlcsordulás így T = 2^16 *8/1 000 000 Hz = 0,524 s-onként következik be. A LED-ek villogási periódusa ennek kétszerese lesz, 1,048 s, ami nagyjából 1 s-nak vehető. ACLK beállításával most nem foglalkozunk.

7_1. lista: A timer_poll program listája

  1. #include "io430.h"
  2.  
  3. void main (void) {
  4.   WDTCTL = WDTPW|WDTHOLD;           // Letiltjuk a watchdog időzítőt
  5.   P1OUT = BIT0;                     // Alaphelyzet: LED1 be , LED2 ki
  6.   P1DIR = BIT0|BIT6;                // P1.0 (LED1) és P1.6 (LED2) kimenet
  7.   TACTL = MC_2|ID_3|TASSEL_2|TACLR; // Beállítjuk és elindíjuk Timer_A-t
  8. // Folyamatos számlálás, 8-cal osztás, SMCLK a forrás, TAR törlés
  9.   while(1) {
  10.     while (!TACTL_bit.TAIFG);       // Várunk TAIFG bebillenésére
  11.     TACTL_bit.TAIFG = 0;            // Töröljük a jelzőbitet
  12.     P1OUT ^= BIT0|BIT6;             // LED-ek állapotának átbillentése
  13.   }
  14. }

A program elején letiltjuk WDT-t, s beállítjuk a P1 portot. Induláskor LED1 világít, LED2 pedig nem. A TACTL regiszter beállításával konfiguráljuk és indítjuk a számlálót (az MCx bitcsoport minden nullától különböző beállítása engedélyezi a számlálást). Az MC_2 makró folyamatos számlálást ír elő. ID_3 a bemeneti osztót 1:8 leosztásra állítja, a frekvencia így f = SMCLK/8 = kb. 125 000 Hz lesz. TASSEL_2 az SMCLK forrást választja ki. A TACLR használatának itt most nincs jelentősége, de szokjuk meg, hogy induláskor nullázni illik a számlálót, hogy ismert alaphelyzetből induljunk. A makrókat az io430g2231.h fejléc állomány definiálja.

A végtelen ciklusban egy beágyazott ciklusban várunk a TAIFG bit bebillenésére (a cilusmag üres, tehát a várakozás alatt nem csinálunk semmit). A TACTL_bit.TAIFG ugyanazt jelenti, mintha azt írtuk volna: TACTL&TAIFG, amivel a TAIFG bit állapotát vizsgáhatjuk. A felkiáltójel pedig a logikai negáció jele, amire azért van szükség, mert akkor várakozunk, amikor TAIFG nulla, tehát a while ciklus teljesüléséhez ellenkezőjére kell változtatnunk TAIFG értékét. Természetesen ugyanezt a feltételt így is írhattuk volna:

   

  1. while (TACTL_bit.TAIFG==0);       // Várunk TAIFG bebillenésére

Amikor a számláló túlcsordul, s a TAIFG jelzőbit bebillen, akkor a while ciklus befejeződik, s a következő utasításnál folytatódik a program. Ekkor törölnünk kell a TAIFG jelzőbitet, s átbillentjük a LED-ek állapotát.  A külső while ciklusnak köszönhetően ekkor újra várakozás következik, majd újabb félmásodperc elteltével megint bebillen TAIFG, s ez így folytatódik a kikapcsolásig.

Pontosítsuk az időzítést!

Az előző példában csak hozzávetőlegesen tudtuk beállítani az időzítést, mert csak az adott arányú leosztások között válogathattunk. A beállítási pontatlanság abból adódott, hogy folyamatos számlálás esetén a számláló 65535 után (hexadecimálisan 0xFFFF) csordul túl, nekünk pedig a fenti példánál 62499-nél kellett volna. A megoldást a számláló "fölfelé számlálás adott számig" üzemmódja jelenti számunkra, mert itt a 16 bites TACCR0 regiszterbe beírt szám után következik be a túlcsordulás, s abba 0 és 65535 között bármilyen számot beírhatunk.

A pontosabb beállításhoz az előző programot csak minimális mértékben kell módosítani:

  • TACCR0-ba beírjuk a számlálás felső korlátját (62499).
  • MCx = 2 helyett MCx = 1-et írunk a TACTL regiszterbe.

Az alábbi programban a fentieken kívül  még annyi változtatást csináltunk, hogy a gyárilag kalibrált 1 MHz-es beállítást használjuk (persze, ezt megtehettük volna az előző programnál is).

7_2. lista: A timer_ccr0 program listája

  1. #include "io430.h"
  2.  
  3. void main (void) {
  4.   WDTCTL = WDTPW|WDTHOLD;           // Letiltjuk a watchdog időzítőt
  5.   DCOCTL = CALDCO_1MHZ;             // DCO beállítása a gyárilag kalibrált
  6.   BCSCTL1 = CALBC1_1MHZ;            // 1 MHz-es frekvenciára  
  7.   P1OUT = BIT0;                     // Alaphelyzet: LED1 be , LED2 ki
  8.   P1DIR = BIT0|BIT6;                // P1.0 (LED1) és P1.6 (LED2) kimenet
  9.   TACCR0 = 62499;                   // periódus = 62500 ciklus  
  10.   TACTL = MC_1|ID_3|TASSEL_2|TACLR; // Beállítjuk és elindíjuk Timer_A-t
  11. // Folyamatos számlálás, 8-cal osztás, SMCLK a forrás, TAR törlés
  12.   while(1) {
  13.     while (!TACTL_bit.TAIFG);       // Várunk TAIFG bebillenésére
  14.     TACTL_bit.TAIFG = 0;            // Töröljük a jelzőbitet
  15.     P1OUT ^= BIT0|BIT6;             // LED-ek állapotának átbillentése
  16.   }
  17. }

Megjegyzés: Ne feledjük el, hogy a számlálási periódus TACCR0+1, tehát esetünkben 62500 lesz. Mivel a számláló bemenőjele SMCLK/8 = 125 000 Hz, így a fenti számlálási periódussal TAIFG beállása (amikor a LED-ek állapotát átbillentjük) 0,5 s-onként következik be.

Megszakítás keltése a Timerrel 

Természetesen nem túl elegáns dolog szoftveres lekérdezéssel figyelni a TAIFG bit állapotát, használhatjuk helyette a Timer egység által keltett megszakításokat. Ez azért is előnyös, mert akkor a várakozások szünetében a CPU más, hasznos feladatot is végezhet, vagy pedig "takarékra teszi magát".

A Timer_A egység megszakításáról tudnunk kell, hogy összesen három megszakítást generáló forrása van: TAIFG, CCIFG0 és CCIFG1, melyekhez csak két megszakítási vektor tartozik. A TIMERA0_VECTOR-t kizárólag a CCIFG0 megszakítás használja. A TIMERA1_VECTOR pedig megosztott használatú, CCIFG1 és TAIFG használja. Megjegyezzük, hogy a nagyobb kiépítettségű mikrovezérlőknél (pl. MSP430G2452, MSP430G2553)  a Timer_A modulnak harmadik Capture/Compare csatornája is van, így a megosztott használatú TIMERA1_VECTOR-t aktiválja a CCIFG2 által kiváltott megszakítás is.Annak eldöntésére, hogy melyik forrás generálta a megszakítást, hasznáhatjuk a TAIV regisztert. Ennek kiolvasásakor automatikusan törlődik a megszakítást kiváltó jelzőbit is. A TAIV regiszter lehetséges értékeihez tartozó megszakításokat az alábbi táblázat szerint kell értelmezni:

TAIV tartalma A megszakítás forrása Jelzőbit Prioritás
0x0000 Nincs kiszolgálásra váró megszakítás    
0x0002 Capture/Compare 1. csatorna CCIFG1 Magas
0x0004 Capture/Compare 2. csatorna CCIFG2  
0x0006 későbbi fejlesztésnek fenntartva    
0x0008 későbbi fejlesztésnek fenntartva    
0x000A Timer túlcsordulás TAIFG Alacsony

Megszakítás TAIFG használatával

Kezdjük a bonyolultabb esettel: a Timer túlcsordulás okozta megszakítással! Az alábbi programban ehhez a TAIE bittel kell engedélyezzük a megszakítást, s az osztott vektor használata miatt a TAIV vektorból olvassuk ki a megszakítás okát. Ez utóbbit egyébként elhagyhattuk volna, hiszen most csak egy forrás okozhatja a megszakítást.

7_3. lista: A timer_int program listája

  1. #include "io430.h"
  2.  
  3. void main (void) {
  4.   WDTCTL = WDTPW|WDTHOLD;           // Letiltjuk a watchdog időzítőt
  5.   P1OUT = BIT0;                     // Alaphelyzet: LED1 be , LED2 ki
  6.   P1DIR = BIT0|BIT6;                // P1.0 (LED1) és P1.6 (LED2) kimenet
  7. //Folyamatos számlálás, 8-cal osztás, SMCLK a forrás, interrupt engedélyezés  
  8.   TACTL = MC_2|ID_3|TASSEL_2|TAIE;  // Beállítjuk és elindíjuk Timer_A-t
  9.    __low_power_mode_0();            // MCLK = KI, GIE = BE
  10. }
  11.  
  12. #pragma vector=TIMERA1_VECTOR
  13. __interrupt void Timer_A(void) {
  14.    switch( TAIV ) {
  15.      case  2: break;                // TACCR1 nincs használatban
  16.      case 10: P1OUT ^= BIT0|BIT6;   // LED-ek állapotának átbillentése
  17.               break;
  18.    }
  19. }

 

Ez a program a 7_1. listán bemutatott program átirata, azzal kell összehasonlítani. Kikerült belőle a szoftveres lekérdezés, és a végtelen ciklus, helyette energiatakarékos módban altatjuk a CPU-t. Mivel a DCO oszcillátort és az SMCLK órajeket is használjuk, csak MCLK kikapcsolására van lehetőség, ami az LPM0 módot jelenti. TACTL beállításánál a TACLR bitet csak helyhiány miatt hagytuk ki, hogy ne legyen túl hosszú a programsor.

A megszakításnál meg kell adni, hogy a TIMERA1_VECTOR-hoz tartozik a kiszolgáló eljárás. A TAIV regiszter tartalmát legcélszerűbben egy switch utasítással használhatjuk fel. A regiszter kiolvasása egyúttal törli is a megszakítást okozó bitet, ezért a 7_1. programban látott TAIFG törlésre itt nincs szükség.

Megszakítás CCIFG0 használatával

A CCIFG0 használatával keltett megszakítás kiszolgálása egyszerűbb, mivel a TIMERA0_VECTOR nem megosztott használatú, így nem kell nézegetni, hogy melyik bit okozta a megszakítást. A következő programban a 7_2. listán bemutatott programot alakítjuk át interruptos kezelésre.

7_4. lista: A timer_ccr0_int program listája

  1. #include "io430.h"
  2.  
  3. void main (void) {
  4.   WDTCTL = WDTPW|WDTHOLD;           // Letiltjuk a watchdog időzítőt
  5.   DCOCTL = CALDCO_1MHZ;             // DCO beállítása a gyárilag kalibrált
  6.   BCSCTL1 = CALBC1_1MHZ;            // 1 MHz-es frekvenciára  
  7.   P1OUT = BIT0;                     // Alaphelyzet: LED1 be , LED2 ki
  8.   P1DIR = BIT0|BIT6;                // P1.0 (LED1) és P1.6 (LED2) kimenet
  9.   TACCR0 = 62499;                   // periódus = 62500 ciklus  
  10.   TACCTL0 = CCIE;                   // CCR0 interrupt engedélyezése
  11. // Folyamatos számlálás, 8-cal osztás, SMCLK a forrás, TAR törlés  
  12.   TACTL = MC_1|ID_3|TASSEL_2|TACLR; // Beállítjuk és elindíjuk Timer_A-t
  13.    __low_power_mode_0();            // MCLK = KI, GIE = BE  
  14. }
  15.  
  16. #pragma vector=TIMERA0_VECTOR
  17. __interrupt void Timer_A (void)
  18. {
  19.   P1OUT ^= BIT0|BIT6;               //A  LED-ek állapotának átbillentése
  20. }

 

A TIMERA0_VECTOR nem megosztott használatú, ezért a CCIFG0 megszakításjelző bit automatikusan törlődik. A magszakítást kiszolgáló eljárásban csak a kívánt feladatot kell elvégeznünk (itt most a LED-ek állapotát billentjük át).


A cikk még nem ért véget, lapozz!
Következő: »»   7 / 8
Értékeléshez bejelentkezés szükséges!
Bejelentkezés

Belépés
Hirdetés
XDT.hu
Az oldalon sütiket használunk a helyes működéshez. Bővebb információt az adatvédelmi szabályzatban olvashatsz. Megértettem