ABX00087 UNO R4 WiFi Entwicklungsboard
Cricket-Schlagerkennung mit Arduino UNO R4 WiFi + ADXL345 + Edge
Impuls
Dieses Dokument beschreibt den vollständigen Workflow für den Aufbau eines Systems zur Erkennung von Cricket-Schlägen mithilfe eines Arduino UNO R4 WiFi, eines ADXL345-Beschleunigungssensors und Edge Impulse Studio. Das Projekt umfasst die Erfassung von Beschleunigungssensordaten, das Training eines Machine-Learning-Modells und die Übertragung des trainierten Modells auf den Arduino zur Echtzeit-Klassifizierung der Schläge.
Im Rahmen dieses Projekts berücksichtigte Cricket-Schläge:
– Cover Drive
– Gerader Antrieb
– Pull Shot
Schritt 1: Hardwareanforderungen
– Arduino UNO R4 WiFi
– ADXL345 Beschleunigungsmesser (I2C)
– Überbrückungskabel
– Steckbrett (optional)
– USB-Typ-C-Kabel
Schritt 2: Softwareanforderungen
– Arduino IDE (neueste Version)
– Edge Impulse Studio-Konto (kostenlos)
– Edge Impulse CLI-Tools (Node.js erforderlich)
– Adafruit ADXL345 Bibliothek
Schritt 3: Verdrahtung des ADXL345
Verbinden Sie den ADXL345-Sensor wie folgt mit dem Arduino UNO R4 WiFi:
VCC → 3.3 V
Masse → Masse
SDA → SDA (A4)
SCL → SCL (A5)
CS → 3.3 V (optional, für I2C-Modus)
SDO → schwebend oder GND
Schritt 4: IDE-Sensor bereit machen
Wie installiere ich Sensorbibliotheken in der Arduino IDE?
Öffne die Arduino IDE.
Öffnen Sie „Tools“ → „Bibliotheken verwalten…“ und installieren Sie: Adafruit ADXL345 Unified, Adafruit Unified Sensor
(Falls Sie stattdessen LSM6DSO oder MPU6050 besitzen: Installieren Sie SparkFun LSM6DSO, Adafruit LSM6DS oder MPU6050 entsprechend.)
Schritt 5: Arduino-Sketch zur Datenerfassung
Laden Sie dieses Sketch auf Ihren Arduino UNO R4 WiFi hoch. Es streamt Beschleunigungsmesserdaten im CSV-Format (x,y,z) mit ~18 Hz für Flankenimpulse.
#enthalten
#enthalten
Adafruit_ADXL345_Unified accel =
Adafruit_ADXL345_Unified(12345);
void setup() {
Seriell.begin(115200);
if (!accel.begin()) {
Serial.println(“Kein ADXL345 erkannt”);
während (1);
}
accel.setRange(ADXL345_RANGE_4_G);
}
void schleife() {
sensors_event_t e;
accel.getEvent(&e);
Serial.print (e.acceleration.x);
Serial.print(“,”);
Serial.print(e.acceleration.y);
Serial.print(“,”);
Serial.println(e.acceleration.z);delay(55); // ~18 Hz
}
Edge Impulse einrichten
Schritt 6: Verbindung zu Edge Impulse herstellen
- Schließe den seriellen Monitor des Arduino.
- Führen Sie den Befehl aus: edge-impulse-data-forwarder –frequency 18
- Achsennamen eingeben: accX, accY, accZ
- Benennen Sie Ihr Gerät: Arduino-Cricket-Board
- Bestätigen Sie die Verbindung in Edge Impulse Studio unter „Geräte“.
Schritt 7: Datenerfassung
In Edge Impulse Studio → Datenerfassung:
– Gerät: Arduino-Cricket-Board
– Sensor: Beschleunigungsmesser (3 Achsen)
- SampLänge des Bildes: 2000 ms (2 Sekunden)
– Frequenz: 18 Hz
Mindestens 40 Sekunden aufzeichnenampLes pro Klasse:
– Cover Drive
– Gerader Antrieb
– Pull Shot
Daten sammeln (Beispiel)amples
Abdeckungsantrieb
Gerät: Arduino-Cricket-Board
Label: Cover Drive
Sensor: Sensor mit 3 Achsen (accX, accY, accZ)
Sample Länge: 10000ms
Frequenz: 18 Hz
Example Rohdaten:
accX -0.32
accY 9.61
accZ -0.12
Gerader Antrieb
Gerät: Arduino-Cricket-Board
Bezeichnung: Gerader Antrieb
Sensor: Sensor mit 3 Achsen (accX, accY, accZ)
Sample Länge: 10000ms
Frequenz: 18 Hz
Example Rohdaten:
accX 1.24
accY 8.93
accZ -0.42
Pull Shot
Gerät: Arduino-Cricket-Board
Bezeichnung: Pull Shot
Sensor: Sensor mit 3 Achsen (accX, accY, accZ)
SampDateilänge: 10000 ms
Frequenz: 18 Hz
Example Rohdaten:
accX 2.01
accY 7.84
accZ -0.63 
Schritt 8: Impulsdesign
Impuls öffnen:
Eingabeblock: Zeitreihendaten (3 Achsen).
Fenstergröße: 1000 ms Fenstervergrößerung (Schrittweite): 200 ms Aktivieren: Achsen, Amplitude (optional), Frequenz 18.
Verarbeitungsblock: Spektralanalyse (auch bekannt als spektrale Merkmale für Bewegung). Fenstergröße: 1000 ms. Fensterschrittweite: 200 ms. Aktivieren: Achsen, Amplitude (optional), zunächst alle Standardeinstellungen beibehalten.
Lernblock: Klassifizierung (Keras).
Klicken Sie auf „Impuls speichern“. 
Funktionen generieren:
Gehen Sie zu Spektralanalyse, klicken Sie auf Parameter speichern und anschließend auf Merkmale für den Trainingsdatensatz generieren.
Trainieren Sie ein kleines Modell
Gehen Sie zu Classifier (Keras) und verwenden Sie eine kompakte Konfiguration wie die folgende:
Neuronales Netzwerk: 1–2 dichte Schichten (z. B. 60 → 30), ReLU
Epochen: 40–60
Lernrate: 0.001–0.005
Losgröße: 32
Datenaufteilung: 80/20 (Trainings-/Testdaten)
Daten speichern und trainieren
Evaluieren und überprüfen Sie die Modelltests mit dem Holdout-Set.
Überprüfen Sie die Konfusionsmatrix; falls sich Kreis und oberer Bereich überschneiden, sammeln Sie weitere, vielfältigere Daten oder passen Sie die Matrix an.
Spektrale Parameter (Fenstergröße / Rauschpegel).
Schritt 9: Bereitstellung auf Arduino
Gehen Sie zu Bereitstellung:
Wählen Sie die Arduino-Bibliothek (die C++-Bibliothek funktioniert auch).
Aktivieren Sie den EON Compiler (falls verfügbar), um die Modellgröße zu verringern. 
Laden Sie die .zip-Datei herunter und gehen Sie dann in der Arduino IDE wie folgt vor: Sketch → Bibliothek einbinden → .ZIP-Bibliothek hinzufügen… Dadurch wird die Bibliothek hinzugefügt.amples wie Statischer Puffer und Kontinuierlich unter File → Bspamples →
Ihr Projektname – Edge Impulse. Inferenzskizze für Arduino UNO EK R4 WiFi + ADXL345.
Schritt 10: Arduino-Inferenzskizze
#enthalten
#enthalten
#enthalten // Ersetzen Sie dies durch den Edge Impulse-Header
Adafruit_ADXL345_Unified accel =
Adafruit_ADXL345_Unified(12345);
static bool debug_nn = false;
void setup() {
Seriell.begin(115200);
while (!Serial) {}
if (!accel.begin()) {
Serial.println(“FEHLER: ADXL345 nicht erkannt”);
während (1);
}
accel.setRange(ADXL345_RANGE_4_G);
}
void schleife() {
float buffer[EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE] = {0};
for (size_t ix = 0; ix < EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE; ix +=
3) {
uint64_t next_tick = micros() + (EI_CLASSIFIER_INTERVAL_MS *
1000);
sensors_event_t e;
accel.getEvent(&e);
buffer[ix + 0] = e.acceleration.x;
buffer[ix + 1] = e.acceleration.y;
buffer[ix + 2] = e.acceleration.z;
int32_t wait = (int32_t)(next_tick – micros());
if (wait > 0) delayMicroseconds(wait);
}
signal_t Signal;
int err = numpy::signal_from_buffer(buffer,
EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE, &signal);
if (err != 0) return;
ei_impulse_result_t result = {0};
EI_IMPULSE_ERROR res = run_classifier(&signal, &result,
debug_nn);
if (res != EI_IMPULSE_OK) return;
for (size_t ix = 0; ix < EI_CLASSIFIER_LABEL_COUNT; ix++) {
ei_printf(“%s: %.3f “, result.classification[ix].label,
result.classification[ix].value);
}
#if EI_CLASSIFIER_HAS_ANOMALY == 1
ei_printf(“Anomalie: %.3f”, result.anomaly);
#endif
ei_printf(“\n”);
}
Ausgabe Bspampauf:
Tipps:
Halten Sie EI_CLASSIFIER_INTERVAL_MS mit der Frequenz Ihres Datenweiterleitungsgeräts synchron (z. B. 100 Hz → 10 ms). Die Edge Impulse-Bibliothek setzt diese Konstante automatisch anhand Ihres Impulses.
Wenn Sie eine kontinuierliche Erkennung (gleitendes Fenster) wünschen, beginnen Sie mit der Option „Kontinuierliche Erkennung“.ample wurde in die EI-Bibliothek aufgenommen und in den ADXL345-Reads ausgetauscht.
Wir werden in Kürze Video-Tutorials hinzufügen; bis dahin bleiben Sie dran – https://www.youtube.com/@RobuInlabs
Und falls Sie noch Zweifel haben, können Sie sich dieses Video von Edged Impulse ansehen: https://www.youtube.com/watch?v=FseGCn-oBA0&t=468s
Dokumente / Ressourcen
 |
Arduino ABX00087 UNO R4 WiFi Entwicklungsboard [pdf] Benutzerhandbuch R4 WiFi, ADXL345, ABX00087 UNO R4 WiFi Entwicklungsboard, ABX00087, UNO R4 WiFi Entwicklungsboard, WiFi Entwicklungsboard, Entwicklungsboard, Board |