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

» Több friss téma
Cikkek » Tényleg nincs királyi út? I. rész
Tényleg nincs királyi út? I. rész
Szerző: icserny, idő: Jún 22, 2013, Olvasva: 26939, Oldal olvasási idő: kb. 9 perc
Lapozás: OK   5 / 8

Szenzorok

Ebben a fejezetben különféle szenzorok használatával ismerkedünk meg. A szenzorok feladata az, hogy valamilyen fizikai mennyiséget (hőmérséklet, relatív páratartalom, távolság) a mikrovezérlő által érzékelhető elektromos jellé alakítsák. Az így kapott jel lehet analóg, amelyet az ADC-vel kel digitális jellé alakítani, vagy lehet eleve digitális, amelyet a digitális perifériák segítségével olvashatunk be. Határeset az ultrahangos távolságmérő szenzor, amely digitális jelet produkál, de a jel időtartama változó, s ez hordozza a számunkra érdekes analóg jelet.

Mintapélda: hőmérés a beépített szenzorral

Kezdjük a szenzorok használatát a beépített hőmérővel! Ennek legfőbb előnye az, hogy az MSP430 mikrovezérlőnkben eleve benne van, nem kell hozzá beszerezni semmit. A beépített hőmérő a mikrovezérlő szilíciumlapkájának hőmérsékletét méri, ami nem feltétlenül egyezik meg a környezet hőmérsékletével. Emellett a hőmérő offszethibája is nagy, tehát ha ha a hőmérséklet valódi értékét akarjuk meghatározni, akkor a hőmérőt kalibrálni kell. 

A belső hőmérő használatához az ADC 10. csatornáját kell kiválasztani. Az MSP430x2xx Family User's Guide szerint a hőmérő a Celsius fokokban mért TEMPC hőmérséklet hatására az alábbi képlettel számítható VTEMP névleges feszültséget adja (Voltban kifejezve):

VTEMP=0.00355*TEMPC+0.986

Ehhez a feszültséghez tartozó analóg-digitális konverzió eredmény:

ADCMEM = VTEMP*1023/VREF

A fenti két egyenletből behelyettesítéssel és átrendezéssel a hőmérséklet kifejezhető:

TEMPC = (ADCMEM * VREF/1023 - 0.986)/0.00355

Mivel a mérendő jel viszonylag kicsi, a konverziót célszerű a belső 1,5 V-os referenciához viszonyítva végezni (VREF = 1.5 V).

Hardver feltételek:

- Launchpad kártya MSP430G2553, MSP430G2452 vagy MSP430G2231 mikrovezérlővel

- MSP430G2553 mikrovezérlő esetén az RX/TX átkötéseket hardveres, a többi mikrovezérlő esetén pedig szoftveres UART állásba hell helyezni

Az előkészítő részben így adhatjuk meg, hogy az ADC az 1,5 V-os belső referenciát használja:

  1. analogReference(INTERNAL1V5);

Az eredmény átszámításhoz kényelmi okokból lebegőpontos (float) típusú változót használunk. Ez erőforrás pazarló megoldás, de gyakorlati jelentőség itt most nincs. A számolások egyszerűsítése céljából a konstans kifejezéseket előre kiszámoltuk:

VREF/1023/0.00355 = 0.413  és  0.986/0.00355 = 277.8

Az eredményt a szokásos módon, a soros porton keresztül íratjuk ki. A Celsius fokokban mért hőmérséklet mellett az ADC-ből kiolvasott nyers értéket is kiíratjuk.

 

 temperaturesensor_listing.png

5_1. ábra: A TemperatureSensor program listája

A program futási eredménye az alábbi ábrán látható. Az egyik dolog, ami feltűnő, hogy a mutatott hőmérséklet legalább 3-4 fokkal fölé lő a környezet hőmérsékletének (a mérés kb. 26°C-os helyiségben történt). A másik sajnálatos dolog az, hogy az értékek nagy szórást mutatnak, s ez az Energia hibás ADC kezelésének tulajdonítható (saját C prgrammal nem ugráltak így az eredmények).

 temperaturesensor.png

5_2. ábra: A TemperatureSensor program futásának eredménye

 

Mintapélda: Hőmérséklet és relatív páratartalom mérés DHT22 (AM2302) szenzorral

A következő mintaprogramban a DHT22 szenzort használjuk (a Ghuangzou Aosong Electronic Co. Ltd. ezt AM2302 néven forgalmazza). A négy kivezetéses tokban helyezkedik el a hőmérő, a relatív páratartalom mérő és egy 8 bites mikrovezérlő, amely a gyári kalibrációs adatokat tartalmazza és az egyvezetékes digitális kommunikációt lebonyolítja. A szenzorból a hőmérséklet Celsius fokokban, 0,1 °C felbontással, a relatív páratartalom pedig százalékben, 0,1 %-os felbontással digitálisan olvasható ki.

DHT22
5_3. ábra: DHT22 (AM2302) hőmérséklet és relatív páratartalom szenzor

Bekötés:

1-es láb (a képen a bal szélső): VCC, azaz 3,3 - 5 V közötti tápfeszültség

2. láb: SDA, azaz digitális I/O

3. láb: NC, azaz nincs bekötve

4. láb: GND, a közös pont

 

Megjegyzések:

  1. Az SDA lábat elvileg egy 4,7 - 10 kΩ közötti értékű ellenállással fel kellene húzni a tápfeszültségre, de eddigi próbálkozásaim során erre nem volt szükség.
  2. Bár a kommunikáció egyvezetékes, de nem kompatibilis a Dallas 1-wire protokollal.
  3. Több szenzor használata esetén külön-külön adatvezetékeket kell használni.

Hardver követelmények:

  • MSP430 Launchpad kártya
  • DHT22 szenzor az alábbi bekötési vázlat szerint csatlakoztatva

dht22_wiring.png

5_4. ábra: A DHT22 szenzor bekötési vázlata

A szenzor kezeléséhez Rob Tillart DHTLib programkönyvtárát és mintaprogramját fogjuk használni, amely DHT22 és DHT11 szenzorok használatára egyaránt használható. Mivel ez nem része a "gyári" Energia kiadásnak, külön be kellett szerezni és be kellett illeszteni az Energia programkönyvtárai közé. A felhasználó által telepített könyvtári modulokat a saját vázlatfüzet (Sketch book) libraries nevű mappájában kell elhelyezni. Ez nálam a Dokumentumok\Energia\libraries mappában található, ebben kell létrehozni egy DHTLib nevű almappát, s ide kell bemásolni a dht.h és dht.cpp állományokat.  Opcionálisan a DHTLib-en belül egy examples almappát is létrehozhatunk az eredeti mintaprogram számára.

Megjegyzés: ez a példa is jól mutatja az Arduino kompatibilis platform előnyét, hiszen a DHTLib programkönyvtár és mintapélda Arduino környezethez készült (ATMEGA168 vagy ATMEGA328 mikrovezérlőhöz), mi pedig akár változtatás nélkül használhatjuk az MSP430 Launchpad kártyához!

Az eredeti mintaprogram egy DHT11 és egy DHT22 szenzort használt, melyek közül a DHTLIB_test.ino programban csak a DHT22 kezelését hagytam meg. (A DHT11 egyébként hasonló működésű, de butább, kisebb felbontású szenzor).

  1. /*
  2.  * DHTLib_test.ino
  3.  * DHT22 hőmérséklet és relatív páratartalom szenzor próba
  4.  *
  5.  * Szerző: Rob Tillaart (01/04/2011)
  6.  * Módosítás: Cserny István 2013.
  7.  */
  8.  
  9. #include
  10. dht DHT;
  11.  
  12. #define DHT22_PIN P1_6
  13.  
  14. void setup()
  15. {
  16.   Serial.begin(9600);
  17.   Serial.println("DHT TEST PROGRAM ");
  18.   Serial.print("LIBRARY VERSION: ");
  19.   Serial.println(DHT_LIB_VERSION);
  20.   Serial.println();
  21.   Serial.println("Type,\tstatus,\tHumidity (%),\tTemperature (C)");
  22. }
  23.  
  24. void loop() {
  25.   delay(2000);
  26.   // READ DATA
  27.   Serial.print("DHT22, \t");
  28.   int chk = DHT.read22(DHT22_PIN);
  29.   switch (chk)   {
  30.     case DHTLIB_OK:
  31.                 Serial.print("OK,\t");
  32.                 break;
  33.     case DHTLIB_ERROR_CHECKSUM:
  34.                 Serial.print("Checksum error,\t");
  35.                 break;
  36.     case DHTLIB_ERROR_TIMEOUT:
  37.                 Serial.print("Time out error,\t");
  38.                 break;
  39.     default:
  40.                 Serial.print("Unknown error,\t");
  41.                 break;
  42.   }
  43.   // DISPLAY DATA
  44.   Serial.print(DHT.humidity, 1);
  45.   Serial.print(",\t");
  46.   Serial.println(DHT.temperature, 1);
  47. }

 

A szenzor kezelését a dht objektumosztály példányosításával kell kezdeni. A DHT22 szenzor a read22() metódussal olvasható ki. Paraméterként meg kell adni azt a kivezetést, amelyhez  hozzárendeljük a szenzor SDA lábát (esetünkben a P1_6 kivezetést használtuk, de bármelyik szabad digitális I/O láb választható). Egy DHT11 típusú szenzor hasonló módon a read11() metódussal lenne kiolvasható.

Megjegyzés: A DHT22 szenzor viszonylag lassú, a kiolvasások között legalább 2 másodperc szünetet kell tartani!

Kiolvasáskor a visszatérési érték jelzi, hogy sikeres volt-e a kiolvasás. A kiolvasott értékek a dht objektum lebegőpontos típusú humidity és temperature nevű publikus változóiból vehetők elő.

A kiolvasott eredményket a szokásos módon a soros porton keresztül íratjuk ki, a kiíratást 1 tizedesjegyre végezzük. Egy tipikus futás eredménye az alábbi ábrán látható.

dhtlib_res.png

5_5. ábra: A DHTLib_test program futási eredménye

 

Relatív páratartalom és hőmérséklet mérése grafikus kijelzéssel

Ennek a mintapéldának az alapötlete és eredeti programjai Rajendra Bhatt honlapjáról (www.embedded-lab.com) származnak. Az eredeti projekt DHT11 szenzort használt, ezért a programokat módosítani kellett, hogy a DHT22 szenzor nagyobb felbontását kihasználhassuk.  Az eredeti projektben PIC32 alapú CHIPKit UNO32 kártyát használtak, ami az MPIDE nevű, szintén Arduino alapú fejlesztői környezetben programozható. Az Arduino kompatibilitásnak köszönhetően a programot elvileg módosítás nélkül is használhattuk volna, ha DHT11 szenzort használunk. A DHT22 szenzorra való tekintettel azonban egyszerűbbnek bizonyult az előző mintaprogram "lebutított" (kevesebb kiírást tartalmazó ) változatát használni.

Hardver követelmények:

  • MSP430 Launchpad kártya
  • DHT22 szenzor az 5_4. ábra szerint csatlakoztatva

A projekt két programot igényel: az MSP430 Launchpad kártyán futó firmware és a PC-n futó, Processing környezetben fejlesztett alkalmazás kell hozzá.

A mikrovezérlőn futó alkalmazás

Az MSP430 Launchpad kártyán futó program az előző példához hasonlóan rendszeres időközönként kiolvassa a DHT22 szenzor adatait, majd a soros porton keresztük kiküldi azokat a PC felé. Az egyszerűsített kiíratás szerint egy sor csak két számot tartalmaz, amelyeket egy szóközzel választunk el.

5_3. lista: A TRHlogger program listája

  1. #include "dht.h"
  2.  
  3. dht DHT;
  4.  
  5. #define DHT22_PIN   P1_6
  6.  
  7. void setup()  
  8. {
  9.   Serial.begin(9600);
  10. }
  11.  
  12. void loop()
  13. {
  14.   delay(5000);
  15.   int chk = DHT.read22(DHT22_PIN);
  16.   if(chk==DHTLIB_OK)
  17.   {
  18.     Serial.print(DHT.humidity,1);
  19.     Serial.write(' ');
  20.     Serial.println(DHT.temperature,1);
  21.   }
  22. }

A PC-n futó alkalmazás

A PC-n futó alkalmazás módosításához vagy újrafordításához telepíteni kell a Processing fejlesztői környezetet. A cikk szoftver-mellékletében azonban lefordított bináris programot is mellékeltünk, tehát az egyszerű futtatáshoz nincs szükség a Processing fejlesztői környezet telepítésére, csupán a Java Futtatói Környezet (JRE) kell hozzá. A Processing programok ugyanis Java nyelvre fordulnak, s a futtatható programot végeredményben a Java fordító állítja elő (az alapértelmezett Processing telepítési csomag tartalmazza a Java fordítót is).

  5_4. lista: a Processing nyelven megírt, DHT22 szenzorhoz módosított alkalmazás listája

  1. /*
  2.  Project:     Temperature and relative humidity logger for DHT22
  3.  Description: Receives temperature and relative humidity bytes
  4.  from USB-UART port and displays the temperature on a graphics window.
  5. It also provides Start/Stop button for logging the temperature samples.
  6. The original version is for DHT11.  This (modified) version is for DHT22.
  7.  Written by:  Rajendra Bhatt (www.embedded-lab.com)
  8.  Date:        2012/07/12    
  9.  Adopted by:  Istvan Cserny (esca.atomki.hu/~cserny)
  10.  Date:        2013/02/25
  11. */
  12.  
  13. //import Serial communication library
  14. import processing.serial.*;
  15.  
  16. // Declare variable "a" of type PImage
  17. PImage a;
  18.  
  19. // Variable declaration
  20. PFont font22, font44;
  21. PFont font12;
  22. float tempC, tempF, RH;
  23. float y, h, MS_Byte, LS_Byte;
  24. Serial Dev_Board;
  25. PrintWriter output;
  26. int[] PC_Time = new int[3];
  27. int[] MM_DD_YY = new int[3];
  28. int i, j, xx=-15;
  29. String curr_time, X_Time, curr_date, row_data, filename;
  30. int lf = 10;    // Linefeed in ASCII
  31. String myString = null;
  32.  
  33. // Button
  34. int rectX, rectY;      // Position of square button
  35. int rectSize = 90;     // Diameter of rect
  36. color rectColor, baseColor;
  37. color rectHighlight;
  38. color currentColor;
  39. boolean rectOver = false, data_logg = false ;
  40.  
  41. void setup() {
  42.  
  43. // Define size of window
  44. size(350, 350);
  45.  
  46.   //setup fonts for use throughout the application
  47.   font22 = loadFont("MicrosoftYaHei-22.vlw");
  48.   font12 = loadFont("MicrosoftYaHei-12.vlw");
  49.   font44 = loadFont("FranklinGothic-Demi-32.vlw");
  50.   //init serial communication port
  51.   Dev_Board = new Serial(this, Serial.list()[0], 9600);
  52.  
  53.   smooth();
  54.   rectColor = color(0, 90, 140);
  55.   rectHighlight = color(80);
  56.   rectX = 220;
  57.   rectY = 250;
  58.   ellipseMode(CENTER);
  59.   a=loadImage("waterdrop.jpg");
  60.  
  61. }
  62.  
  63. void draw() {
  64.  
  65.  while (Dev_Board.available() > 0)
  66.  {
  67.  myString = Dev_Board.readStringUntil(lf);
  68.  if (myString != null) {
  69.    String[] myData = split(myString," ");
  70.    MS_Byte=float(myData[0]);  // Converts and prints float
  71.    LS_Byte=float(myData[1]);  // Converts and prints float
  72.  }
  73.  background(255, 255, 255);
  74.  fill(200, 6, 0);
  75.  smooth();
  76.  stroke(0);
  77.  strokeWeight(2);
  78.  ellipse(100, 280, 58, 50);
  79.  noStroke();
  80.  fill(0, 46, 200);
  81.  arc(100, 60, 30, 20, PI, PI+PI);
  82.  rect(85,60,30,200);
  83.  // Capillary
  84.  fill(250,250, 250);
  85.  //stroke(0);
  86.  rect(95,60,10,200);
  87.  
  88.  // Marks on thermometer
  89.  stroke(0);
  90.  strokeWeight(1);
  91.  textAlign(RIGHT);
  92.  fill(0,46,250);
  93.  for (int i = 0; i < 5; i += 1) {
  94.   line(70, 230-40*i, 80, 230-40*i);
  95.   if(i < 4) line(75, 210-40*i, 80, 210-40*i);
  96.   textFont(font12);
  97.   text(str(40+20*i), 65, 235-40*i);
  98.  }
  99.  image(a, 180, 130);
  100.  // Centigrade
  101.  textAlign(LEFT);
  102.  for (int i = 0; i < 6; i += 1) {
  103.   line(118, 242-35*i, 128, 242-35*i);
  104.   if(i < 5) line(118, 225-35*i, 123, 225-35*i);
  105.   textFont(font12);
  106.   text(str(0+10*i), 135, 247-35*i);
  107.  }
  108.  
  109.  noStroke();
  110.  // text font
  111.  fill(0,46,250);
  112.  
  113.  textFont(font22);
  114.  textAlign(LEFT);
  115.  text("F", 57, 46);
  116.  text("C", 135, 46);
  117.  textFont(font12);
  118.  text("o", 45, 35);
  119.  text("o", 125, 35);
  120.  
  121.  fill(0,102,153);
  122.  textFont(font22);
  123.  text("o", 300+xx, 45);
  124.  text("o", 300+xx, 85);
  125.  
  126.  // DHT11
  127.  tempC = LS_Byte;
  128.  RH = MS_Byte;
  129.  tempF = ((tempC*9)/5) + 32;
  130.  textFont(font44);
  131.  text(nfc(tempC, 1), 220+xx, 60);
  132.  text(nfc(tempF, 1), 220+xx, 100);
  133.  text("C", 320+xx, 60);
  134.  text("F", 320+xx, 100);
  135.  
  136.  // Print Relative Humidity
  137.  textFont(font44);
  138.  text(nfc(RH, 0), 240, 190);
  139.  text("%",310 , 190);
  140.  // Raise mercury level
  141.  fill(200,0, 0);
  142.  y = -2.0*tempF + 310;
  143.  h = 270-y;
  144.  rect(95, y, 10, h);
  145.  curr_time = PC_Time();
  146.  curr_date = PC_Date();
  147. // println(curr_date);
  148.  
  149.  if (data_logg){
  150.  row_data = curr_date + "  "+ curr_time + "  " + nfc(tempC, 1) + "  " + nfc(tempF, 1) + "  " + nfc(RH, 0);
  151. // println(row_data);
  152.  output.println(row_data);
  153.  }
  154. }
  155.  
  156. update(mouseX, mouseY);
  157.   if(rectOver) {
  158.     fill(rectHighlight);
  159.   } else {
  160.     fill(rectColor);
  161.   }
  162.   stroke(210);
  163.   rect(rectX, rectY, rectSize, rectSize-45);
  164.   textFont(font12);
  165.   textSize(14);
  166.   if(data_logg){
  167.    fill(250,255,252);
  168.  
  169.    text("Stop Log", rectX+15, rectY+25);
  170.   }
  171.   if(!data_logg){
  172.   fill(250,255,252);
  173.   text("Start Log", rectX+15, rectY+25);
  174.   }
  175.  
  176. }
  177.  
  178. void update(int x, int y)
  179. {
  180.   if ( overRect(rectX, rectY, rectSize, rectSize-45) ) {
  181.     rectOver = true;
  182.     } else {
  183.     rectOver = false;
  184.   }
  185. }
  186.  
  187. void mousePressed()
  188. {
  189.   if(rectOver) {
  190.     if(data_logg){
  191.      data_logg = false;
  192.      output.flush(); // Write the remaining data
  193.      output.close(); // Finish the file
  194.  
  195.   } else {
  196.     data_logg = true;
  197.    // Create a new file in the sketch directory
  198.    curr_date = PC_Date();
  199.    curr_time = PC_Time();
  200.    String[] temp = split(curr_date, "  ");
  201.    filename = "DataLogger_"+join(temp, "");
  202.    temp = split(curr_time, "  ");
  203.    filename = filename+join(temp, "")+".txt";
  204.    output = createWriter(filename);
  205.    output.println("MM  DD  YYYY  HH  MM  SS    C     F   RH(%)");
  206.      
  207.   }
  208.   }
  209. }
  210.  
  211. boolean overRect(int x, int y, int width, int height)
  212. {
  213.   if (mouseX >= x && mouseX
  214.       mouseY >= y && mouseY
  215.     return true;
  216.   } else {
  217.     return false;
  218.   }
  219. }
  220.  
  221. String PC_Time()
  222. {
  223.  
  224.  PC_Time[2] = second();  // Values from 0 - 59
  225.  PC_Time[1] = minute();  // Values from 0 - 59
  226.  PC_Time[0] = hour();    // Values from 0 - 23
  227.  return join(nf(PC_Time, 2), "  ");
  228.  
  229. }
  230.  
  231. String PC_Date()
  232. {
  233.  
  234.  MM_DD_YY[2] = year();
  235.  MM_DD_YY[1] = day();
  236.  MM_DD_YY[0] = month();  
  237.  return join(nf(MM_DD_YY, 2), "  ");
  238. }

 

A PC-n futó alkalmazás - azon kívül, hogy beolvassa és a képernyőn kijelzi a virtuális soros porton érkező adatokat, kezel egy egérrel kattintható gombot, amely elindítja, illetve leállítja a naplózást. A naplófájlban soronként időbélyeggel ellátva tárolódnak el a beolvasott páratartalom és hőmérséklet adatok.

dht22_logger.jpg

 5_6. ábra: A TRHlogger és dht22_logger programok futási eredménye

 

Mintapélda: Ultrahangos távolságmérés

A következő példában egy HC-SR04 ultrahangos távolságmérő szenzort használunk, amellyel kb. 2 - 200 cm tartományban mérhetünk. A szenzor modul egy ultrahang adóból, egy ultrahang vevőből és a jelfeldolgozó elektronikából áll. A szenzor modul +5 V-os tápfeszültséget igényel. Ezért az Echo kimenet jele is 5 V körüli, amit nem vezethetünk közvetlenül a mikrovezérlőnk bemenetére, hanem egy feszültségosztót, vagy legalább egy áramkorlátozó ellenállást be kell iktatni. Utóbbi esetben a mikrovezélő bemenetéhez tartozó belső védődióda végzi a feszültség korlátozását. 

A négy kivezetés bekötése az alábbi:

1. VCC (+5 V-ot igényel)

2. Trigger (min. 10 μs széles impulzust vár)

3. Echo (a jelterjedési időnek megfelelő szélességű impulzus)

4. GND (a közös pont)

 hc-sr04.jpg

 5_7. ábra: A HC-SR04 ultrahangos távolságmérő szenzor

sonar_signal.png

5_8. ábra: A HC-SR04 szenzor jeleinek idődiagramja

sonar2.png

5_9. ábra: Az ultrahangos távolságmérő kapcsolási vázlata

Amint a fenti ábrán láthatjuk, az ultrahangos szenzor +5 V-os tápfeszültségét az USB csatlakozó melletti TP1 pontról kell vennünk, mert a mikrovezérlő által használt 3,5 V nem elegendő a működéséhez. Az Echo kimenet jelének korlátozását itt a védődiódára bíztuk, de ez esetben szükségünk van egy áramkorlátozó ellenállásra. 

A mintaprogramban az Echo impulzus szélességét a pulseIn(láb,HIGH) függvény segítségével mérjük meg.  Az első paraméter a bemenetet jelöli ki, a második pedig azt mondja meg, hogy az aktív szint magas, vagy alacsony. Mivel az időmérés az átmenetek észlelése között végrehajtott utasításciklusok számával történik, ezért a mérés kissé pontatlan, az eredmény megbízhatatlan. Pontosabb méréshez hardveres időmérést kell megvalósítani egy Timer valamelyik Input Capture moduljának segítségével. Ezt azonban az Energia gyári függvényei jelenleg még nem támogatják, magunknak kellene megírni.

Az itt bemutatott mintaprogramot Arduino kártyához írták, az eredeti program az arduinobasics.blogspot.hu honlapról tölthető le. Az MSP430 Launchpad kártyához történő adaptálás során a programot gyakorlatilag csak a fenti kapcsoláshoz tartozó lábkiosztáshoz kellett hozzáigazítani. A program listája és eredménye az alábbi ábrákon látható.

sonar_listing.png

5_10. ábra: A Sonar program listája

sonar_results.png

5_11. ábra: A  Sonar program futási eredménye

 Megjegyzés: Az ultragangos távolságmérő előtt egy tárgyat fokozatosan távolítottunk.


A cikk még nem ért véget, lapozz!
Következő: »»   5 / 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