Arduino GIGA R1 WiFi – przesyłanie obrazu USB do tabletu Android, przykład programu ArduCAM OV5642

Pytanie

Jak wyświetlić na tablecie z systemem android przewodowo USB obraz z arduino GIGA, podaj przykładowy program?

Odpowiedź Sztucznej Inteligencji

Bezpośrednia odpowiedź na pytanie

• Arduino GIGA nie posiada sprzętowego interfejsu UVC, dlatego nie może być rozpoznane przez tablet jako „kamera USB”. Obraz należy przesyłać jako strumień danych przez USB CDC (Serial) lub USB HID i zdekodować go w aplikacji na Androidzie.
• Najprostszy, stabilny wariant:
  1. Arduino przechwytuje lub generuje obraz (np. z kamery ArduCAM OV5642 lub z pamięci).
  2. Kod Arduino wysyła plik JPEG lub ramkę RGB565 przez SerialUSB w postaci ustalonego protokołu (nagłówek + dane + stopka/CRC).
  3. Tablet (USB OTG) uruchamia aplikację napisaną z użyciem biblioteki usb‑serial‑for‑android, odbiera bajty, rekonstruuje bitmapę i wyświetla ją.

Szczegółowa analiza problemu

1. Sprzęt

• Arduino GIGA R1 WiFi (USB‑C; wsparcie USB Device i USB Host)
• Moduł kamery – np. ArduCAM OV5642 lub prosty moduł SPI (OV2640/OV7670)
• Tablet Android z obsługą USB OTG + przejściówka OTG (USB‑C↔USB‑A)

2. Teoretyczne podstawy

1. USB CDC (Communication Device Class) – Arduino wystawia wirtualny port COM (Serial). Maks. realna przepustowość przy 12 Mb/s (~1 MB/s).
2. Format danych – ze względu na ograniczenia przepustowości najlepiej użyć kompresji JPEG. Przy 320×240 @ 90 kB klatki można osiągnąć kilka fps.
3. Protokół aplikacyjny – nagłówek (MAGIC, długość, CRC), blok danych, stopka. Chroni przed desynchronizacją strumienia.

3. Przykładowy program – Arduino GIGA

Poniższy szkic przechwytuje pojedynczą klatkę JPEG z ArduCAM OV5642 (QVGA 320×240), pakuje w nagłówek i wysyła do hosta.

#include <ArduCAM.h>
#include <SPI.h>

#define CS_PIN   7                // Chip Select kamery
#define BAUD     2000000          // 2 Mb/s – realnie ok. 180 kB/s

ArduCAM cam(OV5642, CS_PIN);

void setup() {
  Serial.begin(BAUD);
  while (!Serial) {}              // czekaj na enumerację USB
  SPI.begin();
  pinMode(CS_PIN, OUTPUT);
  digitalWrite(CS_PIN, HIGH);

  // Szybki test połączenia
  cam.write_reg(ARDUCHIP_TEST1, 0x55);
  if (cam.read_reg(ARDUCHIP_TEST1) != 0x55) {
    Serial.println(F("Kamera nieodpowiada"));
    while (1);
  }

  cam.set_format(JPEG);
  cam.InitCAM();
  cam.OV5642_set_JPEG_size(OV5642_320x240);
  delay(1000);
  Serial.println(F("READY"));
}

void loop() {
  if (Serial.available() && Serial.read() == 'C') { // command 'C' = capture
    sendFrame();
  }
}

void sendFrame() {
  cam.flush_fifo();
  cam.clear_fifo_flag();
  cam.start_capture();

  while (!cam.get_bit(ARDUCHIP_TRIG, CAP_DONE_MASK));

  uint32_t len = cam.read_fifo_length();
  if (len == 0 || len > 250*1024) return;  // sanity check

  // Nagłówek: 0xAB 0xCD + 3‑bajtowa długość
  uint8_t hdr[5] = {0xAB, 0xCD, (uint8_t)(len>>16), (uint8_t)(len>>8), (uint8_t)len};
  Serial.write(hdr, 5);

  cam.CS_LOW();
  cam.set_fifo_burst();
  for (uint32_t i = 0; i < len; i++) {
    Serial.write(SPI.transfer(0x00));
    if (i % 1024 == 0) Serial.flush();     // opróżnij bufor co 1 kB
  }
  cam.CS_HIGH();

  uint16_t crc = 0xFFFF;                   // proste CRC‑16
  Serial.write((uint8_t*)&crc, 2);         // stopka
}

• Komenda 'C' z tabletu uruchamia wykonanie zdjęcia.
• Nagłówek i stopka pozwalają aplikacji Android sprawdzić kompletność klatki.

4. Szkielet aplikacji Android (Kotlin)

Biblioteka: implementation("com.github.mik3y:usb-serial-for-android:3.5.2")

class MainActivity : AppCompatActivity() {
    private lateinit var usbManager: UsbManager
    private var serialPort: UsbSerialPort? = null
    private val ioExecutor = Executors.newSingleThreadExecutor()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        usbManager = getSystemService(USB_SERVICE) as UsbManager
        openSerial()
        findViewById<Button>(R.id.btnCapture).setOnClickListener { sendCommand('C'.code) }
    }

    private fun openSerial() {
        val driver = UsbSerialProber.getDefaultProber().findAllDrivers(usbManager).firstOrNull() ?: return
        val conn = usbManager.openDevice(driver.device) ?: return
        serialPort = driver.ports[0].apply {
            open(conn)
            setParameters(2_000_000, 8, UsbSerialPort.STOPBITS_1, UsbSerialPort.PARITY_NONE)
        }
        val manager = SerialInputOutputManager(serialPort, listener)
        ioExecutor.submit(manager)
    }

    private val listener = object : SerialInputOutputManager.Listener {
        private val buffer = ByteArrayOutputStream()
        private var expectedLen = -1
        override fun onNewData(data: ByteArray) {
            for (b in data) processByte(b.toInt() and 0xFF)
        }
        private fun processByte(b: Int) {
            buffer.write(b)
            val arr = buffer.toByteArray()
            if (expectedLen == -1 && arr.size >= 5 && arr[0]==0xAB.toByte() && arr[1]==0xCD.toByte()) {
                expectedLen = (arr[2].toUByte().toInt() shl 16) or
                               (arr[3].toUByte().toInt() shl 8) or arr[4].toUByte().toInt()
                buffer.reset() // usuń nagłówek
            } else if (expectedLen > -1 && buffer.size() >= expectedLen + 2) { // +CRC
                val jpeg = buffer.toByteArray().copyOfRange(0, expectedLen)
                runOnUiThread {
                    val bmp = BitmapFactory.decodeByteArray(jpeg, 0, jpeg.size)
                    findViewById<ImageView>(R.id.imageView).setImageBitmap(bmp)
                }
                buffer.reset(); expectedLen = -1
            }
        }
        override fun onRunError(e: Exception) { e.printStackTrace() }
    }

    private fun sendCommand(c: Int) = serialPort?.write(byteArrayOf(c.toByte()), 10)
}

• Przycisk „Capture” wysyła 'C', aplikacja czeka na nagłówek, odczytuje długość, kolekcjonuje JPEG i wyświetla.
• Do manifestu dodaj <uses-feature android:name="android.hardware.usb.host" android:required="true"/> oraz filtr device_filter.xml z VID/PID Arduino.

5. Praktyczne zastosowania

• Inspekcja obrazu z prostych kamer lub wizualizacja danych graficznych generowanych przez MCU.
• Szybkie laboratoryjne podglądy bez konieczności korzystania z sieci Wi‑Fi.
• Edukacja: demonstracja protokołów USB i przetwarzania obrazu w czasie rzeczywistym.

Aktualne informacje i trendy

• Arduino GIGA w wersji R1 (2023) ma rdzeń STM32H747 (480 MHz) i wbudowany port USB HS (High‑Speed‑PHY) umożliwiający 480 Mb/s w trybie Device/Host. Firmware Core 3.x udostępnia klasy CDC, MSC, HID; prace nad UVC dla STM32 trwają, ale nie trafiły jeszcze do oficjalnego core.
• W świecie Androida biblioteka usb-serial-for-android jest de‑facto standardem (ostatnia stabilna: 3.5.2 – luty 2024).
• Trend: przechodzenie z USB Serial na USB WebUSB lub TinyUSB UVC – gdy pojawi się wsparcie, tablet rozpozna płytkę jako kamerę bez dedykowanej aplikacji.

Wspierające wyjaśnienia i detale

• BaudRate: 2 Mb/s to górna granica stabilnego transferu CDC przy kablu OTG ≤50 cm. Jeżeli strumień się rwie, zmniejsz do 921 600.
• Buforowanie: Serial.flush() po 1–2 kB ogranicza przepełnienie bufora USB.
• CRC: przykład używa stałej 0xFFFF, w produkcji obliczaj CRC‑16/CCITT, aby móc odrzucić uszkodzoną klatkę.

Aspekty etyczne i prawne

• Strumieniowanie obrazu z kamery wiąże się z ochroną wizerunku i prywatności (RODO/GDPR). Zapewnij informację o rejestrowaniu oraz bezpieczne przechowywanie strumienia.
• W urządzeniach medycznych lub przemysłowych pamiętaj o certyfikacji EMC i izolacji galwanicznej USB.

Praktyczne wskazówki

1. Użyj krótkiego, ekranowanego kabla OTG; błędy CRC świadczą zwykle o zakłóceniach.
2. Kompresuj obraz na Arduino (libjpeg‑turbo dla STM32H7) – trzy‑czterokrotne zmniejszenie danych.
3. Przy dłuższych sesjach wyczyść bufor UsbSerialPort (metoda .purgeHwBuffers()) co kilka sekund.

Ewentualne zastrzeżenia lub uwagi dodatkowe

• Brak wsparcia UVC sprawia, że systemowe aplikacje aparatu nie zobaczą Arduino – zawsze potrzebna jest dedykowana aplikacja.
• CDC blokuje połączenie debug‑Serial; używaj osobnego portu SWO lub UART dla debugu.
• Przy transferze >5 fps ograniczeniem staje się SPI‑kamera; rozważ kamerę DCMI (np. OV5640) i DMA do SDRAM.

Sugestie dalszych badań

• Próba implementacji TinyUSB UVC Device na STM32H747 – możliwe ~15 fps @ QVGA.
• Zbadanie protokołu USB Bulk‑Only + MSC: kamera zapisuje JPEG w RAM‑disku, Android montuje ją jako pendrive i odczytuje plik.
• Integracja z WebUSB lub WebSerial pozwoli wyświetlać obraz w przeglądarce Chrome bez aplikacji native.

Krótkie podsumowanie

Arduino GIGA nie wyśle wideo do Androida jak klasyczna kamera, ale przy wykorzystaniu USB CDC można sprawnie przesłać skompresowany JPEG lub ramkę RGB. W praktyce:

1. Zbierz lub wygeneruj obraz na Arduino.
2. Wyślij go z prostym nagłówkiem przez SerialUSB (przykład powyżej).
3. Odbierz w aplikacji Android (biblioteka usb‑serial‑for‑android), zweryfikuj długość/CRC i wyświetl jako Bitmap.
   Rozwiązanie działa stabilnie przy QVGA ≈ 5 fps, a dzięki wysokiej przepustowości USB HS na GIGA możliwe są dalsze optymalizacje lub przejście na UVC w przyszłości.