Bilderkennung mit Arduino Nicla Vision: Ein Radxa ROCK SBC Klassifikator

Dieses Projekt zeigt Ihnen, wie Sie die Bilderkennung auf einem winzigen Arduino Nicla Vision (245-7770) trainieren und Videoaufnahmen in Echtzeit durchführen können, um einen AI ROCK SBC Klassifikator zu erstellen. Nicla Vision ist ein winziges Board mit nur 23 x 23 mm im Quadrat. Sein Hauptmerkmal ist eine 2MP-Farbkamera, die mit einem leistungsstarken STM32H747AII6 Dual ARM® Cortex® M7/M4-Prozessor integriert ist, der in der Lage ist, Videos in Echtzeit zu erfassen und Bilder für Machine Learning (ML)-Anwendungen direkt auf dem Board zu klassifizieren.

Darüber hinaus verfügt es über integriertes Dual-WiFi und Bluetooth Low Energy für die Netzwerkkonnektivität und eine Reihe zusätzlicher Sensoren und Anschlüsse, was es zu einer wirklich flexiblen industriellen Low-Power-Sensorplattform auf kleinem Raum macht:

• 16 MB SPI flash memory
• Omnidirectional MEMS microphone
• Time of Flight distance sensor
• 6-axis accelerometer and gyroscope
• Crypto chip for secure cloud communication
• 7V Li-po battery monitor and battery connector
• 16 GPIO pins (1xUART, 1xSPI, 1xI2C, 2xADC, 2xDigital)
• I2C expansion header connector
• micro USB 5V power connector

Das Board bietet mehrere Programmieroptionen:

• Arduino IDE (C++)
• MicroPython (OpenMV)
• STM32Cube IDE

In diesem Projekt demonstrieren wir, wie man eine komplette Machine-Vision-Anwendung erstellt und testet, die darauf trainiert wurde, ROCK SBCs zu identifizieren, wenn sie im Videostrom erscheinen.
Wir führen Sie durch die folgenden Schritte, die an Ihr eigenes Edge-Imaging-Szenario angepasst werden können:

• Einrichten der Nicla Vision Entwicklungsumgebung
• Videoerfassung mit OpenMV
• Erstellen von ML-Modellen mit EdgeImpulse
• Erstellung der Nicla Vision-Firmware
• Programmierung der Bildverarbeitungs- und ML-Steuerungsanwendung in MicroPython
• Einsetzen und Ausführen der Demo

Sie können eine Video-Demonstration in dieser Bildschirmaufnahme von OpenMV sehen - achten Sie auf die untere linke Seite des seriellen Terminals, um die Druckzeile zu sehen, wenn ein ROCK-Board erkannt wird!

Level: Schwierig

Zeit: 4 Stunden

Schritte: 14

Benötigte Teile:

Schritt 1: Aktualisieren des Bootloaders

Bevor Sie etwas anderes tun, empfiehlt Arduino, den Bootloader zu aktualisieren, da dieser möglicherweise seit der Auslieferung Ihres Boards aktualisiert wurde. Dazu müssen Sie die Arduino-IDE installieren oder ihren Cloud-Service nutzen.
Wir haben für dieses Projekt die neueste Arduino-IDE-Version 2.0.2 auf einem X86-64-PC mit Debian Bullseye verwendet, aber es sollte auch auf einem Mac oder Windows-PC laufen, und die Installationsschritte sind ähnlich. Siehe die Arduino-Software-Seite.

• Laden Sie das AppImage von der Arduino-Software-Seite herunter (oder die Version für Ihr Betriebssystem).
• Geben Sie dem AppImage Ausführungsrechte:

chmod +x arduino-ide_2.0.2_Linux_64bit.AppImage

• Fügen Sie eine neue udev-Regel für das Nicla Vision in /etc/udev/rules.d hinzu
• Erstellen Sie die Regel mit dem Namen 50-nicla.rule mit Ihrem bevorzugten Editor - achten Sie auf die Produkt-ID, da sie nicht das ist, was Sie sehen, wenn sich das Board zum ersten Mal am USB-Bus anmeldet:

cat /etc/udev/rules.d/50-nicla.rules
ATTRS{idProduct}=="035f", ATTRS{idVendor}=="2341", MODE="664", GROUP="dialout"

• Überprüfen Sie, ob Ihr Benutzer Mitglied der Dialout-Gruppe ist:

id
uid=1000(pete) gid=1000(pete) groups=1000(pete),7(lp),20(dialout),24(cdrom),25(floppy),27(sudo),29(audio),30(dip),44(video),46(plugdev),108(netdev),115(lpadmin),118(scanner),998(docker)

• Fügen Sie sich, wenn nicht, der Dialout-Gruppe hinzu

sudo usermod -aG dialout $USER

• Neustart
• Danach starten Sie Arduino IDE aus einem Terminal:

./arduino-ide_2.0.2_Linux_64bit.AppImage

• Jetzt können Sie Ihr Nicla Vision mit einem hochwertigen microUSB-Kabel an den Host-PC anschließen
• Wählen Sie den Nicla Vision aus der Board-Auswahl oben im IDE-Fenster aus
• Wählen Sie aus dem Menü Datei -> Beispiele -> STM32H747_System -> STM32H747_manageBootloader
• Wenn die Anwendung geöffnet wird, kompilieren und erstellen Sie das Image und flashen Sie die Nicla Vision mit der Menüoption Sketch -> Upload
• Auf der Registerkarte Output am unteren Rand des Fensters sollten Sie den Fortschritt des Flashen sehen können.
• Wenn das Image erfolgreich geflasht wurde, öffnen Sie die Registerkarte Serial Monitor und folgen Sie den Anweisungen, die auf dem Monitor ausgegeben werden, um den Bootloader zu aktualisieren.
• Nachdem der Vorgang abgeschlossen ist, trennen Sie die Nicla Vision und schließen Sie die Arduino IDE.

So updaten Sie den bootloader.

Tipp: Wenn Sie Probleme haben, überprüfen Sie die udev-Regeln und stecken Sie Ihren Nicla Vision aus und wieder ein.

Schritt 2: OpenMV Installation

In diesem Schritt installieren wir die Programmierumgebung Open MV IDE, die MicroPython auf der Nicla Vision unterstützt. Dies ermöglicht die Programmierung von Python-Anwendungen, die die Kamera steuern, um Dinge wie Objekterkennung und Bildklassifizierung durchzuführen, Ausgänge auszulösen und die anderen Sensoren zu verwenden.

• Öffnen Sie die OpenMV download page im browser und laden Sie die für Sie passende Datei herunter
• Öffnen Sie ein Terminal, wechseln Sie in das Verzeichnis Downloads, geben Sie der heruntergeladenen Datei Ausführungsrechte und führen Sie das Installationsprogramm aus:

./openmv-ide-linux-x86_64-2.9.7.run

• Folgen Sie den Anweisungen des Installationsprogramms in dem sich öffnenden Dialogfeld und installieren Sie die Anwendung in Ihrem Home-Verzeichnis, indem Sie die Standardeinstellungen übernehmen.
  Wählen Sie, um die Anwendung zu öffnen.

Schritt 3: OpenMV Machine Vision

Jetzt können Sie das Nicla Vision an OpenMV anschließen und einen Test durchführen, um sicherzustellen, dass alles wie erwartet funktioniert.

• Schließen Sie bei laufendem OpenMV Ihr Nicla Vision mit einem hochwertigen Micro-USB-Kabel an den Host-PC an.
• Klicken Sie auf das Symbol USB Connect in der linken unteren Ecke der OpenMV-IDE:

• Die LED am Nicla beginnt grün zu blinken, was anzeigt, dass er sich im Bootloader-Modus befindet, und der Verbindungsdialog wird geöffnet.
• Wählen Sie die Option Neueste Firmware installieren, aber NICHT die Option Internes Dateisystem löschen.

• Die OpenMV-Firmware wird nun auf das Nicla Vision geflasht.
• Schließen Sie den Dialog, wenn der Flashvorgang abgeschlossen ist.
• Die LED am Nicla sollte nun blau blinken.
• Klicken Sie auf OK, und Sie kehren zur IDE zurück, und die LED erlischt.
• Wählen Sie nun im Hauptmenü Datei -> Neue Datei und fügen Sie den folgenden Code in das Code-Editor-Fenster ein und speichern Sie ihn als test.py - damit wird die Kamera gestartet und der Feed in der IDE angezeigt. Wir werden ihn auch verwenden, um Bilder für das ML-Modell zu erfassen:

import sensor, image, time

sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.set_vflip(True)
sensor.set_hmirror(True)
sensor.skip_frames(time = 2000)

clock = time.clock()

while(True):
    clock.tick()
    img = sensor.snapshot()
    print(clock.fps())

• Klicken Sie auf die grüne dreieckige Start-Schaltfläche unter der Schaltfläche „Verbinden“ - die Kameraübertragung wird im IDE-Fenster angezeigt, ebenso wie die dynamische Farbbalance.
• Die Start-Schaltfläche verwandelt sich in ein rotes Quadrat, auf das Sie klicken können, um den Test zu beenden.

Jetzt ist NiclaVision fertig zum Einsatz mit OpenMV.

Step 4: ML Data Set

In den nächsten Schritten geht es darum, einen Bilddatensatz zu erstellen, mit dem wir unser Bildverarbeitungsmodell aufbauen können. Dazu werden Videobilder aus dem Kamerastrom erfasst und in einem Datensatz gespeichert.
Wir werden unser Modell darauf trainieren, ROCK 4SE (220-9536) und ROCK 5B (249-3159) im Videostream zu erkennen, also müssen wir viele Bilder von diesen beiden Tafeln, die unser Ziel sind, sowie einige Hintergrundbilder aufnehmen. Wir werden also 3 Datenklassen haben: ROCK-4, ROCK-5 und Hintergrund.
Wir werden etwa 50 Bilder von jeder Tafel und dem Hintergrund aus verschiedenen Winkeln und bei unterschiedlicher Beleuchtung aufnehmen. Je mehr Abwechslung Sie haben, desto genauer wird Ihr Modell wahrscheinlich sein.

• Legen Sie irgendwo auf Ihrem PC ein Verzeichnis an, in dem Sie die Bilder speichern - wir nennen es Dataset.
• Wenn Ihre Nicla Vision mit OpenMV verbunden ist, klicken Sie erneut auf die Schaltfläche Verbinden und starten Sie die Kamera über die Schaltfläche Start.
• Wählen Sie im Menü Tools -> Dataset Editor -> New Dataset.
• Die Dateiauswahl wird geöffnet - wählen Sie das Dataset-Verzeichnis, und die Datei dataset_capture_script.py wird im Code-Editor geöffnet. Schließen Sie diese Datei, da wir bereits ein Erfassungsskript aus dem Test erstellt haben.
• Klicken Sie auf die Schaltfläche Neue Klasse im linken Fenster und geben Sie Ihrer Klasse einen Namen - wir haben unsere Rock genannt - um die ROCK-4SE-Bilder zu sammeln.

• Klicken Sie nun auf die Schaltfläche Datenerfassung, um Ihr erstes Objektbild zu erfassen.

• Bewegen Sie die Kamera zu einer anderen Ansicht und klicken Sie erneut auf die Aufnahme.
• Wiederholen Sie diesen Vorgang mit verschiedenen Ansichten, bis Sie etwa 40 bis 50 verschiedene Bilder Ihres Zielobjekts haben.
• Sobald Sie genügend Bilder des ersten Objekts haben, erstellen Sie eine neue Datenklasse und nehmen Bilder des nächsten Zielobjekts und des Hintergrunds auf, wobei Sie ihnen separate Klassennamen geben.

Schritt 5: EdgeImpulse

Für die Erstellung des Modells für maschinelles Lernen wird EdgeImpulse Studio verwendet. Es enthält eine Reihe von Tools zur Erstellung des Modells und zur Generierung einer C++-Bibliothek, die für die Inferenz und die Bildklassifizierung verwendet werden kann, damit Nicla erkennen kann, wenn Zielobjekte im Videostrom erscheinen.

EdgeImpulse hat gratis Konten für Developer, besuchen Sie deren Webseite wenn Sie noch kein Konto haben.

• Sobald Sie ein Konto erstellt haben, melden Sie sich an und erstellen ein neues Projekt. Daraufhin wird der Dialog zur Projekteinrichtung geöffnet, in dem Sie den Projektnamen festlegen, den Projekttyp auf der Grundlage der Bildgebung auswählen und ein einzelnes Objekt klassifizieren können.
• Das Projekt wird in der Dashboard-Ansicht mit den verfügbaren Aktivitäten am linken Rand und dem Hauptfenster als Arbeitsbereich geöffnet.

Schritt 6: Data Acquisition

Nachdem das Projekt in EdgeImpulse erstellt wurde, müssen wir nun die Bilddaten hochladen, die wir mit der Nicla Vision-Kamera aufgenommen haben.

• Klicken Sie in der linken Navigationsleiste auf die Aktivität Datenerfassung.
• Klicken Sie auf Dateien auswählen und wählen Sie die Bilder der Felszielklasse aus Ihrem Datensatzverzeichnis aus.
• Geben Sie den Bildern eine Bezeichnung und beginnen Sie mit dem Upload.
• Wiederholen Sie den Vorgang für jede Ihrer Datenklassen.

Sie sollten nun alle Ihre Daten in EdgeImpulse geladen haben und zur Verarbeitung bereit sein. Die Daten werden automatisch in Modellierungsdaten und Testdatensätze aufgeteilt.

Schritt 7: Impulse

Im nächsten Abschnitt geht es um die Erstellung eines Impulses. Damit werden alle Parameter für die Erstellung des ML-Modells festgelegt. EdgeImpulse führt Sie Schritt für Schritt durch diesen Prozess und gibt Ihnen am Ende einen Hinweis darauf, wie genau Ihr Modell wahrscheinlich sein wird. Je nachdem, was Sie zu erkennen versuchen, müssen Sie diese Schritte unter Umständen iterativ durchlaufen und verschiedene Optionen ausprobieren, um die optimale Leistung zu erzielen.

Laut EdgeImpulse lag die Genauigkeit unseres Modells bei knapp 70 %, aber es zeigte eine gute Leistung und identifizierte sowohl die ROCK-4SE- als auch die ROCK-5B-Platten sehr genau.

• Klicken Sie in der Menüleiste auf die Aktivität Impuls erstellen.
• Fügen Sie einen Bildverarbeitungsblock hinzu.
• Fügen Sie einen Transfer-Learning-Block hinzu.
• Setzen Sie die Bildgröße auf 96 X 96.
• Klicken Sie auf Impuls speichern.

Im nächsten Schritt werden die Modellparameter festgelegt und aus den Objektbildern ein Merkmalssatz erzeugt:

• Klicken Sie in der Menüleiste auf das Element Bild.
• Setzen Sie die Farbtiefe auf RGB.
• Klicken Sie auf Parameter speichern.

Wählen Sie dann „Features generieren“ und „Alle Elemente“ - dies löst einen Remote-Auftrag in der EdgeImpulse-Cloud aus, um die Modellfeatures zu generieren.

In diesem Stadium können Sie mit dem Feature-Explorer prüfen, ob die Features ausreichend deutlich sind, um gute Ergebnisse zu erzielen. Sie suchen nach eindeutigen Clustern von Merkmalen mit möglichst wenig Überschneidungen. Unser Modell ist nicht so gut abgegrenzt, weil die beiden ROCK-Platten einige Ähnlichkeiten aufweisen, aber in der Praxis funktioniert es trotzdem gut.

Jetzt können wir mit dem Training unseres Modells beginnen, indem wir die aufgenommenen Bilder aus unserem Trainingsdatensatz verwenden.

• Klicken Sie in der Menüleiste auf Lernen übertragen.
• Stellen Sie die Anzahl der Trainingszyklen = 80 ein.
• Wählen Sie MobileNet 96 x 96 0.1Modellund bearbeiten Sie die Parameter.
• Stellen Sie Neuronen = 12 und Dropout Rate = 0.15 ein.
• Klicken Sie auf Training starten.

Das Training kann je nach Datenmenge und Komplexität der Merkmale mehrere Minuten dauern.
Wenn es beendet ist, erhalten Sie eine Statistik über die Effektivität Ihres Modells, und Sie können sehen, wie die Trainingsergebnisse in der Datenexplorer-Ansicht geclustert sind.

Sie können auf die falschen Ergebnisse klicken, um das Bild zu sehen, das zu diesem Ergebnis geführt hat.

Der letzte Schritt im Prozess der Modellerstellung besteht darin, das Modell mit einem beschrifteten Testdatensatz zu testen, um zu sehen, wie gut es funktioniert. Einige Ihrer Daten werden zu Testzwecken zurückgehalten worden sein, oder Sie können weitere Bilder hinzufügen, um den Test durchzuführen.

• Wählen Sie Model Testing aus dem Menü
• Clicken Sie Classify All.

Ein weiterer ferngesteuerter Auftrag wird gestartet und führt die Testdaten mit dem Modell durch, um Ihnen nach Abschluss die Ergebnisse zu liefern. Unser Test schien nicht sehr genau zu sein, aber er hat trotzdem gut funktioniert.

Schritt 8: OpenMV library

Da wir nun ein funktionierendes Bildverarbeitungsmodell haben, können wir mit EdgeImpulse eine OpenMV-Bibliothek generieren, die auf die Nicla Vision geflasht und von einem Python-Skript aufgerufen werden kann.

• Wählen Sie Bereitstellung aus der Menüleiste
• Wählen Sie OpenMV aus dem Abschnitt Bibliothek
• Klicken Sie auf Erstellen

Dadurch wird die Datei erstellt, dann wird ein Dateibrowser geöffnet, um den Download-Speicherort einzugeben - Sie erhalten ein Zip-Archiv, das etwa so aussieht:

ei-nicla-rock-id-openmv-v2.zip

• Speichern Sie das zip und extrahieren es in Ihren Ordner

Schritt 9: Firmware

Der nächste Abschnitt ist ein schlauer Weg, um die Firmware für die Nicla Vision mit einem GitHub-Workflow-Prozess zu erstellen, der von OpenMV erstellt wurde, um diesen Prozess zu automatisieren. Dies bedeutet, dass Sie die Arm-Toolchain nicht auf Ihrem Host-Rechner installieren müssen, da der Build in der GitHub-Cloud erfolgt.

Sie brauchen einen GitHub account 

• Loggen Sie sich in Gihub und Fork Repo ein.
• Fork the following GH repo.
• Klonen Sie es auf Ihren PC

git clone git@github.com:<your-github-account>/openmv-nicla-test.git

Die Modellbibliothek hat 2 Komponenten, die in der zuvor heruntergeladenen .zip-Datei enthalten sind: das TensorFlow-Modell (trained.tflite) und eine Textdatei mit den Zielbeschriftungen (lable.txt). Wir müssen die Originaldateien, die sich im Verzeichnis src/lib/libtf/models des geklonten Repo befinden, durch unsere eigenen Modelldateien ersetzen.

cd openmv-nicla-test/src/lib/libtf/models
rm *.tflite *.txt
cp ../ei-nicla-rock-id-openmv-v2/trained.tflite rock_detection.tflite
cp ../ei-nicla-rock-id-openmv-v2/lable.txt rock_detection.txt

Übertragen Sie nun die Änderungen und pushen Sie sie zurück auf GitHub.

git add .
git commit
git push

Wenn die Updates auf GitHub gepusht werden, startet ein Workflow und erstellt die neue Firmware für die Nicla Vision - das dauert 2 -3 Minuten.

Der Arbeitsablauf kompiliert die Firmware und veröffentlicht sie als GitHub-Version.

• Klicken Sie auf die Registerkarte „Code“ und dann auf „download the latest Development Release“.
• Klicken Sie auf der Seite Assets auf firmware_NICLAV.zip release.
• Speichern Sie den Download in Ihrem Speicher und entpacken Sie das Archiv.

Sie haben nun die Nicla Vision-Firmware mit dem eingebauten Modell.

Schritt 10: Flashen Sie die Firmware

Wir können nun zu OpenMV zurückkehren und die neue Firmware auf den Nicla Vision flashen.

• 
  Versetzen Sie die Nicla Vision in den Bootloader-Modus, indem Sie auf die Reset-Taste doppelklicken - die grüne LED beginnt zu blinken.
• Klicken Sie auf die Schaltfläche Connect in der IDE - der unten gezeigte Dialog zum Laden einer Firmware wird geöffnet:

• Clicken Sie OK.
• Gehen Sie zu bin file aus dem vorherigen Schritt und klicken Sie Run.

Der Nicla Vision wird mit der neuen Firmware geflasht, die auch das EdgeImpulse-Modell umfasst.

Schritt 11: Python script

Der nächste Schritt besteht darin, ein Python-Skript in OpenMV zu schreiben, um die Nicla-Kamera zu steuern und die ML-Bibliothek zu verwenden, um den Bildstrom zu klassifizieren und zu versuchen, unsere Zielobjekte zu erkennen.
Der Videostrom ist nur eine Reihe von Bildern, die an ein TensorFlow-Objekt übergeben werden, das das Bild mit Hilfe des Modells klassifiziert und eine Vertrauensvorhersage berechnet. Wenn die Konfidenz hoch genug ist, wird das Label überprüft, um zu sehen, welches der ROCK-Boards erkannt wurde. Der Stream wird angehalten, während die Onboard-LED kurz aufleuchtet, um anzuzeigen, ob es sich um einen ROCK 4 oder einen ROCK 5 handelt. Das Ergebnis wird auch an den Ausgang des seriellen Terminals der IDE ausgegeben.

• Wählen Sie File -> New File.
• Fügen Sie den folgenden Python code in den Editor ein

import sensor, image, time, os, tf, pyb

redLED = pyb.LED(1) # built-in red LED
greenLED = pyb.LED(2) # built-in green LED

sensor.reset()                         # Reset and initialize the sensor.
sensor.set_pixformat(sensor.RGB565)    # Set pixel format to RGB565 (or GRAYSCALE)
sensor.set_framesize(sensor.QVGA)      # Set frame size to QVGA (320x240)
sensor.set_vflip(True)
sensor.set_hmirror(True)
sensor.set_windowing((240, 240))       # Set 240x240 window.
sensor.skip_frames(time=2000)          # Let the camera adjust.

labels, net = tf.load_builtin_model('rock_detection')
found = False

def flashLED(led): # Indicate with LED when target is detected
    found = True
    led.on()
    pyb.delay(3000)
    led.off()
    found = False

clock = time.clock()

while not found:
    clock.tick()
    img = sensor.snapshot()
    for obj in tf.classify(net, img, min_scale=1.0, scale_mul=0.8, x_overlap=0.5, y_overlap=0.5):
        print("**********nPredictions at [x=%d,y=%d,w=%d,h=%d]" % obj.rect())
        img.draw_rectangle(obj.rect())
        predictions_list = list(zip(labels, obj.output()))
        for i in range(len(predictions_list)):
            confidence = predictions_list[i][1]
            label = predictions_list[i][0]
            print("%s = %f" % (label, confidence))
            if confidence > 0.8:
                if label == "rock":
                    print("It's a ROCK-4SE")
                    flashLED(greenLED)
                if label == "rock-5":
                    print("It's a ROCK-5B")
                    flashLED(redLED)

    print(clock.fps(), "fps")

• Script speichern als py.

Schritt 12: Demo

Jetzt sind alle Komponenten vorhanden, um die Machine Vision Demo zu starten. Sobald die Kamera initialisiert ist, können Sie den Videorahmen in OpenMV verwenden, um sie auf das Ziel zu richten. Wenn alles gut geht, leuchtet die LED auf, wenn eine der ROCK-Platinen erkannt wird.

• Klicken Sie auf das Etikett Serielles Terminal am unteren Rand der IDE, um das serielle Terminal zu öffnen.
• Klicken Sie auf die Schaltfläche Verbinden in OpenMV.
• Klicken Sie auf die Schaltfläche „Run“ und warten Sie, bis das Skript geladen ist und das Video startet.

Hier ist die Ausgabe, wenn ein ROCK-4SE Board erkannt wird - es dauert nur ein paar Millisekunden!

Schritt 13: Troubleshooting

Nicla Vision kann recht empfindlich auf den Typ des USB-Kabels und sogar auf bestimmte Anschlüsse des Host-PCs reagieren. Wenn Sie Probleme haben, dass sich das Gerät nicht am USB-Bus anmeldet, versuchen Sie einen anderen Anschluss oder ein anderes Kabel.
Sie können die Verbindung des Geräts überprüfen, indem Sie ein Terminal öffnen und den folgenden Befehl ausführen:

sudo dmesg -w

Wenn OpenMV Ihr Nicla Vision immer noch nicht erkennt, prüfen Sie, ob es enumeriert ist und flashen Sie gegebenenfalls den Arduino-Bootloader neu.
Versuchen Sie niemals, den Flash-Speicher zu löschen - wir haben das getan und der Bootloader wurde dadurch beschädigt. Die einzige Möglichkeit, dies zu beheben, war die Verwendung eines STM-Programmiergeräts, um einen neuen Bootloader zu flashen.

 Lesen Sie im forum wie man das mit einem ST32F446 Nucleo board (906-4624) macht.

Fazit

Der Nicla Vision aus der Arduino Pro-Reihe ist ein erstaunliches Gerät für industrielle Bildverarbeitungsanwendungen im Edge-Bereich. Es ist winzig und sehr leistungsfähig für ein so kleines Gehäuse mit geringem Strombedarf.

Dieses Projekt hat gezeigt, wie man eine Anwendung einrichtet und erstellt, die den Unterschied zwischen zwei ROCK-Platten erkennen kann. Unter kontrollierten Bedingungen ist sie sehr genau, und zwar mit einem sehr einfachen Modell, das in EdgeImpulse entwickelt wurde.
Wir haben gezeigt, wie die Bildklassifizierungsinferenz die Onboard-LED auslösen kann, aber dies könnte genauso gut die GPIO-Pins aktivieren, die mit einer industriellen Steuerung in einer Produktionslinie verbunden sind.
Die Möglichkeiten sind endlos! Und nicht zu vergessen: Es gibt einen TOF-Sensor, ein Mikrofon, einen 6-Achsen-Beschleunigungsmesser, WiFi und Bluetooth, einen I2C-Anschluss und einen Batterieanschluss mit Monitor.

Referenzen:

• Machine Vision firmware and scripts
• Arduino Pro product page