Web Serial API: A Webböngészők és Hardveres Eszközök közötti Kapcsolat Hidja

A Web Serial API egy forradalmi technológia, amely lehetővé teszi a webfejlesztők számára, hogy közvetlenül kommunikáljanak soros eszközökkel egy webböngészőn belül. Ez számos lehetőséget nyit meg, a robotok és beágyazott rendszerek vezérlésétől kezdve az érzékelőadatok gyűjtésén át az interaktív fizikai élmények létrehozásáig. Ez az útmutató átfogó áttekintést nyújt a Web Serial API-ról, annak képességeiről és arról, hogyan implementálhatja projektjeiben, célba véve a fejlesztők és lelkes felhasználók globális közönségét.

Mi az a Web Serial API?

A Web Serial API lehetővé teszi a webes alkalmazások számára, hogy soros eszközökkel, például mikrokontrollerekkel, Arduino kártyákkal, 3D nyomtatókkal és más hardverekkel kommunikáljanak közvetlenül a böngészőből. Ez a soros porton keresztül történik, amely egy szabványos interfész az adatkommunikációhoz. Ellentétben a korábbi, bővítményeket vagy natív alkalmazásokat igénylő módszerekkel, a Web Serial API biztonságos és szabványosított módot kínál a hardverrel való interakcióra.

Főbb Jellemzők:

• Biztonságos Hozzáférés: Kizárólag a felhasználó explicit engedélyével férhet hozzá egy adott eszközhöz, ami növeli a biztonságot.
• Platformfüggetlen Kompatibilitás: Különböző operációs rendszereken működik, beleértve a Windows, macOS, Linux és ChromeOS rendszereket, egységes élményt biztosítva.
• Szabványosított API: Konzisztens és könnyen használható JavaScript API-t kínál a soros eszközökkel való interakcióhoz.
• Adatfolyam: Valós idejű adatfolyamot támogat, lehetővé téve az élő adatvizualizációt és interakciót.
• Kétirányú Kommunikáció: Lehetővé teszi az adatok küldését és fogadását a webes alkalmazás és a hardveres eszköz között.

A Web Serial API Használatának Előnyei

A Web Serial API számos előnyt kínál a fejlesztők számára, többek között:

• Egyszerűsített Fejlesztés: Nem szükséges platformspecifikus bővítmények vagy natív alkalmazásfejlesztés, ami leegyszerűsíti a fejlesztési folyamatot.
• Fokozott Elérhetőség: Hozzáférhetőbbé teszi a hardverinterakciót szélesebb közönség számára, mivel a felhasználók közvetlenül a webböngészőjükből vezérelhetik az eszközöket.
• Továbbfejlesztett Felhasználói Élmény: Sima és intuitív felhasználói élményt nyújt, mivel a felhasználók további szoftverek telepítése nélkül léphetnek kapcsolatba a hardverrel.
• Növelt Interaktivitás: Lehetővé teszi a fizikai világgal integrált, erősen interaktív webes alkalmazások létrehozását.
• Globális Elérés: A Web Serial API-val készült webes alkalmazások bármilyen webböngészővel és internetkapcsolattal rendelkező eszközről elérhetők, megkönnyítve a globális együttműködést és innovációt.

Felhasználási Esetek és Példák

A Web Serial API számos projekthez és alkalmazáshoz alkalmazható, többek között:

• Internet of Things (IoT): Webes alkalmazások csatlakoztatása mikrokontrollerek érzékelőadataihoz, irányítópultok létrehozása környezeti monitorozáshoz, okosotthon vezérléséhez és ipari automatizáláshoz. Gondoljon olyan alkalmazásokra, mint a hőmérséklet figyelése egy hollandiai üvegházban, vagy a talajnedvesség nyomon követése egy kenyai farmon.
• Robotika és Automatizálás: Robotok, drónok és más automatizált rendszerek közvetlen vezérlése webes felületről. Ez oktatási célokra (pl. robotprogramozás egy japán iskolában) vagy ipari automatizálásra (pl. gyártósor vezérlése Németországban) használható.
• 3D Nyomtatás Vezérlés: 3D nyomtatók kezelése és figyelése közvetlenül egy webböngészőből, lehetővé téve a felhasználók számára a nyomtatási feladatok távoli feltöltését és vezérlését. Ez különösen hasznos elosztott gyártásban és makerspace-ekben, mint például az Egyesült Államokban vagy Indiában.
• Adatgyűjtés és Vizualizáció: Adatok gyűjtése érzékelőkből (pl. hőmérséklet, nyomás, fény) és valós idejű megjelenítése webes irányítópulton. Ez széles körben alkalmazható, a kanadai tudományos kutatásoktól a brazíliai mezőgazdasági monitoringig.
• Oktatási Projektek: Elektronika, programozás és hardverinterakció tanítása a diákoknak. A Web Serial API egyszerűsége miatt globálisan minden korosztály és hátterű diák számára elérhető.
• Interaktív Installációk: Lenyűgöző és interaktív installációk létrehozása, amelyek reagálnak a felhasználói bevitelre vagy az érzékelőadatokra. Példák erre a művészeti installációk vagy múzeumi kiállítások, amelyek Ausztrália és más országok fizikai számítástechnikai lehetőségeit hasznosítják.

Példa: Arduino Kártya Vezérlése

Készítsünk egy egyszerű példát egy Arduino kártyához csatlakoztatott LED vezérlésére. JavaScriptet fogunk használni parancsok küldésére az Arduinónak, és az Arduino válaszolni fog a LED be- vagy kikapcsolásával.

1. Arduino Kód (Arduino IDE):

            const int ledPin = 13;

void setup() {
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  if (Serial.available() > 0) {
    char command = Serial.read();
    if (command == '1') {
      digitalWrite(ledPin, HIGH);
      Serial.println("LED ON");
    } else if (command == '0') {
      digitalWrite(ledPin, LOW);
      Serial.println("LED OFF");
    }
  }
}

            

              
                Copy
              
            
          

Ez az Arduino kód:

• Beállítja a LED kimenetet kimenetként.
• 9600 baud sebességen inicializálja a soros kommunikációt.
• Folyamatosan ellenőrzi a bejövő soros adatokat.
• Ha adat érkezik, elolvassa a karaktert.
• Ha a karakter '1', bekapcsolja a LED-et.
• Ha a karakter '0', kikapcsolja a LED-et.
• Visszaigazoló üzenetet küld vissza a soros portra.

2. HTML és JavaScript (Webböngésző):

            <!DOCTYPE html>
<html>
<head>
  <title>Web Serial LED Vezérlés</title>
</head>
<body>
  <button id="connectButton">Csatlakozás Arduinohoz</button>
  <button id="onButton" disabled>LED Bekapcsolása</button>
  <button id="offButton" disabled>LED Kikapcsolása</button>
  <p id="status">Nincs csatlakoztatva</p>

  <script>
    const connectButton = document.getElementById('connectButton');
    const onButton = document.getElementById('onButton');
    const offButton = document.getElementById('offButton');
    const status = document.getElementById('status');
    let port;
    let writer;

    async function connect() {
      try {
        port = await navigator.serial.requestPort();
        await port.open({ baudRate: 9600 });
        writer = port.writable.getWriter();
        status.textContent = 'Csatlakoztatva';
        connectButton.disabled = true;
        onButton.disabled = false;
        offButton.disabled = false;
      } catch (error) {
        status.textContent = 'Hiba: ' + error.message;
      }
    }

    async function sendCommand(command) {
      try {
        const data = new TextEncoder().encode(command);
        await writer.write(data);
      } catch (error) {
        status.textContent = 'Hiba parancs küldésekor: ' + error.message;
      }
    }

    async function turnOn() {
      await sendCommand('1');
    }

    async function turnOff() {
      await sendCommand('0');
    }

    connectButton.addEventListener('click', connect);
    onButton.addEventListener('click', turnOn);
    offButton.addEventListener('click', turnOff);
  </script>
</body>
</html>
            

              
                Copy
              
            
          

A JavaScript kód magyarázata:

• Csatlakozás Gomb: Kattintásra soros port hozzáférést kér, és megpróbálja megnyitni azt.
• LED Be/Ki Gombok: A "1" parancsot küldik a LED bekapcsolásához és a "0" parancsot a kikapcsolásához.
• Csatlakozási Állapot: Megjeleníti az aktuális csatlakozási állapotot.
• `navigator.serial.requestPort()`: Felkéri a felhasználót egy soros port kiválasztására.
• `port.open()`: Megnyitja a kiválasztott soros portot. A `baudRate` paraméter az Arduino kódnak megfelelően 9600-ra van állítva.
• `port.writable.getWriter()`: Létrehoz egy írót az adatok soros portra küldéséhez.
• `writer.write(data)`: Az adatokat (a parancsot) a soros portra írja.
• Hibakezelés: Hibakezelést tartalmaz, hogy visszajelzést nyújtson a felhasználónak.

A Példa Futtatása:

1. Csatlakoztassa az Arduinot: Csatlakoztassa az Arduino kártyát a számítógépéhez USB-n keresztül.
2. Töltse fel az Arduino kódot: Nyissa meg az Arduino IDE-t, és töltse fel a megadott kódot az Arduino kártyájára.
3. Hozza létre az HTML fájlt: Mentse el az HTML kódot egy HTML fájlként (pl. `index.html`).
4. Nyissa meg az HTML fájlt böngészőben: Nyissa meg az `index.html` fájlt egy olyan webböngészőben, amely támogatja a Web Serial API-t (pl. Chrome, Edge és néhány Opera verzió).
5. Csatlakozás és Vezérlés: Kattintson a "Csatlakozás Arduinohoz" gombra. A böngésző megkérdezi, hogy melyik soros portot válassza. Válassza ki az Arduinot. Ezután kattintson a "LED Bekapcsolása" és "LED Kikapcsolása" gombokra a LED vezérléséhez.

Első Lépések a Web Serial API-val

A Web Serial API használatának megkezdéséhez a következőkre van szüksége:

• A Web Serial API-t támogató webböngésző: Jelenleg a Chrome, Edge és néhány Opera verzió támogatja. Ellenőrizze a böngésző kompatibilitását olyan forrásokon, mint a Can I Use.
• Hardveres eszköz: Például egy Arduino, Raspberry Pi, vagy bármely soros porton keresztül kommunikáló eszköz.
• HTML, CSS és JavaScript alapvető ismerete: Ezeknek a webes technológiáknak az ismerete elengedhetetlen.

Lépésről Lépésre Útmutató:

1. Soros Port Hozzáférés Kérése: Használja a `navigator.serial.requestPort()` funkciót a felhasználó felkérésére egy soros port kiválasztásához. Ez a funkció egy Promise-ot ad vissza, amely egy `SerialPort` objektummal teljesül. Megjegyzés: a `requestPort()` meghívásához általában felhasználói interakcióra (gombkattintás) van szükség.
2. Soros Port Megnyitása: Hívja meg a `port.open()` metódust, átadva egy konfigurációs objektumot, amely megadja a baud sebességet és más soros port beállításokat (pl. dataBits, stopBits, parity). A baud sebességnek meg kell egyeznie a hardveres eszköz által használt sebességgel.
3. Olvasható és Írható Stream-ek Lekérése: Használja a `port.readable` és `port.writable` tulajdonságokat az olvasható és írható stream-ek lekéréséhez. Ezek a stream-ek az adatok küldésére és fogadására szolgálnak.
4. Író Létrehozása: Használja a `port.writable.getWriter()` metódust egy `writer` objektum létrehozásához, amelyet az eszközre való adatok küldésére fog használni.
5. Olvasó Létrehozása: Használja a `port.readable.getReader()` metódust egy `reader` objektum létrehozásához, amelyet az eszközről érkező adatok fogadására fog használni.
6. Adatok Írása az Eszközre: Használja a `writer.write(data)` parancsot adatok küldésére a soros portra. Az `data` egy `ArrayBuffer` vagy `Uint8Array` kell, hogy legyen. Használhat `TextEncoder`-t egy string átalakításához `Uint8Array`-ra.
7. Adatok Olvasása az Eszközről: Használja a `reader.read()` parancsot adatok olvasására a soros portról. Ez a metódus egy Promise-ot ad vissza, amely egy objektummal teljesül, amely tartalmazza az adatokat és egy logikai értéket, amely jelzi, hogy a stream le van-e zárva.
8. Soros Port Bezárása: Ha végzett, hívja meg a `writer.close()` és `reader.cancel()` parancsokat a stream-ek bezárásához, majd hívja meg a `port.close()` parancsot a soros port bezárásához. Mindig tartalmazzon hibakezelést a soros kommunikációval kapcsolatos potenciális problémák kezelésére.

Kód Példák és Ajánlott Gyakorlatok

Íme több kódrészlet és ajánlott gyakorlat a Web Serial API használatához:

1. Soros Port Kérése:

            async function requestSerialPort() {
  try {
    const port = await navigator.serial.requestPort();
    return port;
  } catch (error) {
    console.error('Hiba a port kérésekor:', error);
    return null;
  }
}

            

              
                Copy
              
            
          

2. Soros Port Megnyitása és Konfigurálása:

            async function openSerialPort(port) {
  try {
    await port.open({
      baudRate: 115200, // Igazítsa az eszközhöz
      dataBits: 8,
      stopBits: 1,
      parity: 'none',
    });
    return port;
  } catch (error) {
    console.error('Hiba a port megnyitásakor:', error);
    return null;
  }
}

            

              
                Copy
              
            
          

3. Adatok Írása a Soros Portra (String):

            async function writeToSerialPort(port, data) {
  const encoder = new TextEncoder();
  const writer = port.writable.getWriter();
  try {
    await writer.write(encoder.encode(data));
  } catch (error) {
    console.error('Hiba íráskor a portra:', error);
  } finally {
    writer.releaseLock();
  }
}

            

              
                Copy
              
            
          

4. Adatok Olvasása a Soros Portról:

            async function readFromSerialPort(port, callback) {
  const reader = port.readable.getReader();
  try {
    while (true) {
      const { value, done } = await reader.read();
      if (done) {
        // Stream lezárva
        break;
      }
      if (value) {
        const decoder = new TextDecoder();
        const decodedValue = decoder.decode(value);
        callback(decodedValue);
      }
    }
  } catch (error) {
    console.error('Hiba olvasáskor a portról:', error);
  } finally {
    reader.releaseLock();
  }
}

            

              
                Copy
              
            
          

5. Soros Port Bezárása:

            async function closeSerialPort(port) {
  if (port) {
    try {
      await port.close();
    } catch (error) {
      console.error('Hiba a port bezárásakor:', error);
    }
  }
}

            

              
                Copy
              
            
          

Ajánlott Gyakorlatok:

• Felhasználói Engedélyek: Mindig kérjen a felhasználótól engedélyt a soros port hozzáféréséhez. A `requestPort()` metódus a kiindulópont.
• Hibakezelés: Implementáljon robusztus hibakezelést a csatlakozási hibák, adatátviteli problémák és váratlan megszakítások szép kezelésére.
• Baud Sebesség Eggyezése: Győződjön meg róla, hogy a webes alkalmazásában lévő baud sebesség megegyezik a hardveres eszköz baud sebességével.
• Adat Kódolás: Használjon `TextEncoder` és `TextDecoder` objektumokat a stringek konzisztens kódolásához és dekódolásához, különösen nemzetközi karakterkészletekkel dolgozva.
• Biztonság: A Web Serial API biztonsági szempontokat figyelembe véve lett tervezve. Csak a felhasználó által kifejezetten jóváhagyott eszközök érhetők el. Kerülje az érzékeny adatok továbbítását titkosítás vagy biztonsági intézkedések nélkül.
• Aszinkron Műveletek: Használja az `async/await` vagy a Promises-t az aszinkron műveletek kezelésére. Ez javítja a kód olvashatóságát és megelőzi a fő szál blokkolását.
• Haladásjelzők: Hosszú műveletek esetén jelenítsen meg haladásjelzőket a felhasználói visszajelzés érdekében és a felhasználói élmény javítása érdekében.
• Böngészőközti Kompatibilitás Tesztelése: Bár a Web Serial API széles körben támogatottá válik, kulcsfontosságú az alkalmazás tesztelése különböző böngészőkben és operációs rendszereken a konzisztens funkcionalitás biztosítása érdekében.
• Tartalék Megoldások Fontolgatása: Azoknál a böngészőknél, amelyek még nem támogatják teljes mértékben a Web Serial API-t, fontolja meg alternatív funkciók felajánlását, vagy útmutatást egy működő verzióhoz való hozzáféréshez.

Adatfolyam és Valós Idejű Alkalmazások

A Web Serial API kiválóan alkalmas adatfolyamok kezelésére, így ideális valós idejű alkalmazásokhoz, amelyek hardveres eszközről származó folyamatos adatátvitelt jelentenek. Ez lehetővé teszi interaktív irányítópultokat, élő adatvizualizációt és reszponzív felhasználói felületeket. Gondoljon olyan példákra, mint a nepáli falu időjárási állomásáról származó valós idejű érzékelőadatok megjelenítése, vagy az Egyesült Államokban működő drón telemetriai adatainak fogadása.

Adatfolyam Példa (Egyszerűsített):

Ez a példa bemutatja az adatok folyamatos olvasását a soros portról, és azok megjelenítését egy webes alkalmazásban:

            async function startStreaming(port, dataCallback) {
  const reader = port.readable.getReader();
  let decoder = new TextDecoder();
  let buffer = '';

  try {
    while (true) {
      const { value, done } = await reader.read();
      if (done) {
        break; // Stream lezárva
      }
      if (value) {
        buffer += decoder.decode(value);
        let newlineIndex = buffer.indexOf('\n'); // Vagy '\r' vagy hasonló lezáró karakter
        while (newlineIndex > -1) {
          const line = buffer.substring(0, newlineIndex);
          dataCallback(line); // Feldolgozza a fogadott adat sort
          buffer = buffer.substring(newlineIndex + 1);
          newlineIndex = buffer.indexOf('\n');
        }
      }
    }
  } catch (error) {
    console.error('Hiba az adatfolyam során:', error);
  } finally {
    reader.releaseLock();
  }
}

            

              
                Copy
              
            
          

Ez a kódrészlet:

• Lekéri az olvasót a soros porthoz.
• A bejövő bájtokat stringgé dekódolja.
• Adatokat fűz egy pufferhez, amíg egy újsor karakter (vagy más elválasztó) nem jelenik meg.
• Amikor egy elválasztó megjelenik, kivon egy teljes adat sort a pufferből, feldolgozza a sort a `dataCallback` függvény meghívásával, és eltávolítja azt a sorból a pufferből.
• A `dataCallback` általában frissíti a weboldalon megjelenített adatokat (pl. frissíti az értéket egy irányítópulton).
• A folyamatot addig folytatja, amíg a stream le nem zárul, vagy hiba nem történik.

Módosíthatja ezt a példát más adatformátumok, például vesszővel elválasztott értékek (CSV) vagy JSON kezelésére, a bejövő adatok elemzésével a `dataCallback` függvényben.

Haladó Témák és Megfontolások

1. Eszköz Szűrés:

A `navigator.serial.requestPort()` használatával történő soros port kérésekor opcionálisan megadhat szűrőket a felhasználónak megjelenített eszközök listájának szűkítésére. Ez különösen hasznos, ha ismeri a keresett eszközt, esetleg annak gyártói vagy termékazonosítóját.

            const port = await navigator.serial.requestPort({
  filters: [
    { usbVendorId: 0x2341, // Arduino Gyártóazonosító
      usbProductId: 0x0043 }, // Arduino Uno Termékazonosító
  ],
});
            

              
                Copy
              
            
          

2. Hibakezelés és Helyreállítás:

A robusztus hibakezelés implementálása kulcsfontosságú. Ez magában foglalja:

• Csatlakozási hibák kezelése.
• Adatátviteli hibák kezelése.
• Eszközök váratlan leválasztásának szép kezelése.

3. Web Workers:

Számításigényes feladatok vagy valós idejű alkalmazások esetén fontolja meg a Web Worker-ek használatát a soros portról érkező adatok feldolgozásának leválasztására a fő szálról. Ez segít megelőzni a felhasználói felület lefagyását és javítja a webalkalmazás válaszkészségét. A fő szálon a soros portról érkező adatok `postMessage()` segítségével továbbíthatók a web workernek, feldolgozhatók a worker szálon belül, és az eredményeket vissza lehet küldeni a fő szálra megjelenítés céljából.

4. Biztonsági Ajánlott Gyakorlatok (További Részletek):

• Felhasználói Hozzájárulás: Mindig kérjen explicit felhasználói engedélyt a soros port eléréséhez. Ne próbáljon meg eszközökhöz hozzáférni a felhasználó jóváhagyása nélkül.
• Eszköz Érvényesítés: Ha lehetséges, ellenőrizze az eszköz típusát vagy gyártóját a kommunikáció létesítése előtt. Ez segít megelőzni, hogy rosszindulatú szereplők az Ön alkalmazását használják jogosulatlan eszközök vezérlésére.
• Adat Érvényesítés: Tisztítsa meg és érvényesítse a soros portról kapott adatokat a feldolgozásuk előtt. Ez segít megelőzni a potenciális injekciós támadásokat vagy adatkárosodást.
• Titkosítás: Ha érzékeny adatokat továbbít soros porton keresztül, használjon titkosítást az adatok védelmére az lehallgatástól. Fontolja meg a TLS/SSL protokollokat, ha alkalmazhatók az Ön alkalmazási környezetében.
• Jogosultságok Korlátozása: Csak azokat a minimális jogosultságokat kérje, amelyekre az Ön alkalmazásának működéséhez szüksége van. Például, ha csak adatokat kell olvasnia egy eszközről, ne kérjen írási jogosultságokat.
• Rendszeres Biztonsági Felülvizsgálatok: Végezzen rendszeres biztonsági felülvizsgálatokat az alkalmazásán, hogy azonosítsa és orvosolja a lehetséges sebezhetőségeket. Frissítse kódját és függőségeit gyakran az ismert biztonsági résesek javítása érdekében.
• Felhasználók Oktatása: Nyújtson világos tájékoztatást a felhasználóknak az alkalmazásuk használatának biztonsági következményeiről és az általuk vezérelt eszközökről. Magyarázza el, miért van szüksége bizonyos eszközök elérésére, és hogyan védi az adataikat.

Közösségi Erőforrások és További Tanulás

A Web Serial API viszonylag új technológia, de egyre növekvő fejlesztői és lelkes felhasználói közössége van. Íme néhány értékes forrás a további tanuláshoz:

• MDN Web Docs: A Mozilla Developer Network (MDN) átfogó dokumentációt nyújt a Web Serial API-hoz, beleértve a részletes magyarázatokat, kódpéldákat és a böngésző kompatibilitási információkat. Keressen rá "Web Serial API MDN" kifejezésre a megtalálásához.
• Google Developers: A Google Developers weboldal cikket, oktatóanyagokat és kódmintákat kínál a Web Serial API-val kapcsolatban, gyakran a gyakorlati alkalmazásokra összpontosítva.
• Web Serial API Példák: Keressen online elérhető kódpéldákat és oktatóanyagokat. Sok fejlesztő osztja meg projektjeit olyan platformokon, mint a GitHub. Keressen példa projekteket olyan alkalmazásokhoz, mint a "Web Serial API Arduino" vagy a "Web Serial API Raspberry Pi".
• Online Fórumok és Közösségek: Vegyen részt online fórumokon és közösségekben, amelyek elkötelezettek a webfejlesztés, a hardverprogramozás és az Internet of Things (IoT) iránt. Népszerű lehetőségek közé tartozik a Stack Overflow, a Reddit (pl. r/webdev, r/arduino) és speciális projektfórumok. Ezek a fórumok lehetőséget kínálnak kérdések feltevésére, segítség kérésére és projektjeinek megosztására másokkal globálisan.
• Nyílt Forráskódú Projektek: Fedezze fel a Web Serial API-t használó nyílt forráskódú projekteket. Ez lehetővé teszi, hogy megvizsgálja, hogyan implementálták más fejlesztők, és tanuljon a megoldásaikból.
• Hardver Gyártók: Ellenőrizze a nagyobb hardvergyártók, mint például az Arduino és a Raspberry Pi dokumentációit és oktatóanyagait, hogy többet tudjon meg termékeik integrálásáról a Web Serial API-val.

Összegzés

A Web Serial API egy hatékony és hozzáférhető technológia, amely lehetővé teszi a webfejlesztők számára, hogy zökkenőmentesen integrálják a webes alkalmazásokat a fizikai világgal. A soros eszközökkel való közvetlen kommunikáció lehetővé tétele révén a Web Serial API számos izgalmas alkalmazás lehetőségét nyitja meg, az egyszerű hardvervezérléstől a kifinomult adatfolyamon és interaktív élményeken át. A vezető szerepben említett információk, példák és ajánlott gyakorlatok felhasználásával a fejlesztők kihasználhatják a Web Serial API potenciálját innovatív megoldások létrehozására és a webes technológia folyamatosan fejlődő tájképéhez való hozzájárulásra. Fogadja el a lehetőségeket, és kezdje el felfedezni a hardverinterakció izgalmas világát a web keresztül!