Hallo, ich wollte fragen ob mir evtl. jemand helfen kann.
Ich müsste einen Zähler bauen welcher hoch und runter zählen kann und mir die Ergebnisse auf einen USB Stick speichern kann.
Also ich möchte etwas drehen und die Umdrehungen zählen und falls ich zu weit gedreht habe wieder zurück zählen können. Die Anzahl der Umdrehungen soll dann als Textdatei auf einem USB Stick gespeichert werden.
ALs Board habe ich ein GIGA R1 Wifi.
Ich habe einfach mal die Vorlage von Arduino mit dem Datenlogger genommen und ich schaffe es irgend wie nicht mal das das Board den USB Stick erkennt.
Ich habe den Stick auf FAT32 Formatiert mit MBR allerdings funktioniert das nicht.
Könnte sich evtl. jemand den Code anschauen und mir einen Tipp geben?
#include <Arduino_USBHostMbed5.h>
#include <DigitalOut.h>
#include <FATFileSystem.h>
USBHostMSD msd;
mbed::FATFileSystem usb("USB_DRIVE");
int err;
int count;
int number_of_readings = 500; //how many readings you want to take
int interval = 2; //how long between readings (milliseconds)
void setup() {
Serial.begin(115200);
pinMode(PA_15, OUTPUT); //enable the USB-A port
digitalWrite(PA_15, HIGH); //write a high state
while (!Serial); //stop program from executing until serial port opens
msd.connect();
while (!msd.connected()) {
Serial.print("USB_DRIVE not found.");
delay(1000);
}
Serial.println("Mounting USB device...");
err = usb.mount(&msd);
if (err) {
Serial.print("Error mounting USB device ");
Serial.println(err);
while (1)
;
}
Serial.print("read done ");
//function to write to file
WriteToFile();
}
//
void loop() {
digitalWrite(PA_15, HIGH); //write a high state
}
void WriteToFile() {
mbed::fs_file_t file;
struct dirent *ent;
int dirIndex = 0;
int res = 0;
Serial.println("Opening file..");
FILE *f = fopen("/USB_DRIVE/log.txt", "w+");
for (int i = 0; i < number_of_readings; i++) {
count += 1;
Serial.print("Reading Nr: ");
Serial.print(count);
Serial.print(", Value: ");
Serial.println(analogRead(A0));
fflush(stdout);
int reading = analogRead(A0);
err = fprintf(f, "%s", "Reading Nr: ");
err = fprintf(f, "%d", count);
err = fprintf(f, "%s", ", Value: ");
err = fprintf(f, "%d\n", reading);
if (err < 0) {
Serial.println("Fail :(");
error("error: %s (%d)\n", strerror(errno), -errno);
}
delay(interval);
}
Serial.println("File closing");
fflush(stdout);
err = fclose(f);
if (err < 0) {
Serial.print("fclose error:");
Serial.print(strerror(errno));
Serial.print(" (");
Serial.print(-errno);
Serial.print(")");
} else {
Serial.println("File closed");
}
}
tippe oder füge den Code hier ein
Genau ich sehe jede Sekunde nur "USB_DRIVE not found."
Dann werde ich mal die USBhost library anschauen und mich evtl in dem GIGA-R1 Unterforum weiter umschauen.
Ich habe gestern einen Giga in Reichweite gehabt und das DirList Beispiel von der Library mit einem älteren USB 2.0 Stick (Corsair 16 GB) getestet. Sah gut aus, der Stick wurde gefunden und die Dateien im Root Verzeichnis und die Namen der Unterverzeichnisse ausgegeben.
Naja, bei einem so neuen Teil, wie dem Giga, würde ich mich nicht darauf verlassen, dass die Doku (und die Beispiel) immer richtig sind.
Aber, wenn das DirList geht, zeigt das ja, dass der Stick verbunden wird. Also geht er in dem Beispiel über die Zeilen weg, die im Datenlogger Sketch nicht funktionieren.
Liegt es vielleicht am Unterschied der Benennenung:
mbed::FATFileSystem usb("usb");
steht in DirList, dagegen im Datenlogger
mbed::FATFileSystem usb("USB_DRIVE");
Du kannst ja mal probieren, ob sich da was ändert, wenn du das umbaust.
Es kann ein paar Tage dauern, bis ich wieder Zeit für den Giga habe. Werde mir das auf jeden Fall noch mal anschauen.
Also ich bin noch nicht schlauer geworden.
Ich habe allerdings schon einmal den Zähler gebaut und wollte nachfragen ob man das so lassen kann oder ob ich da irgend wo Fehler habe. Oder kann man den noch verkleinern oder anders gestalten?
// this constant won't change:
const int buttonPin1 = 2; // links
const int buttonPin2 = 3; // freigabe
const int buttonPin3 = 4; // reset
const int buttonPin4 = 5; // rechts
// Variables will change:
int buttonPushCounter = 0; // zähler
int buttonState1 = 0;
int buttonState2 = 0;
int buttonState3 = 0;
int buttonState4 = 0;
int lastButtonState1 = 0;
int lastButtonState4 = 0;
void setup() {
// initialize as a input:
pinMode(buttonPin1, INPUT);
pinMode(buttonPin2, INPUT);
pinMode(buttonPin3, INPUT);
pinMode(buttonPin4, INPUT);
// initialize as an output:
// initialize serial communication:
Serial.begin(115200);
}
void loop() {
buttonState1 = digitalRead(buttonPin1);
buttonState2 = digitalRead(buttonPin2);
buttonState3 = digitalRead(buttonPin3);
buttonState4 = digitalRead(buttonPin4);
if (buttonState2 == HIGH) {
// compare the buttonState to its previous state
if (buttonState1 != lastButtonState1) {
// if the state has changed, increment the counter
if (buttonState1 == HIGH) {
// if the current state is HIGH then the button went from off to on:
buttonPushCounter++;
Serial.print("Umdrehungen links: ");
Serial.println(buttonPushCounter);
// Delay a little bit to avoid bouncing
delay(5);
}
}
// compare the buttonState to its previous state
if (buttonState4 != lastButtonState4) {
// if the state has changed, increment the counter
if (buttonState4 == HIGH) {
// if the current state is HIGH then the button went from off to on:
buttonPushCounter--;
Serial.print("Umdrehungen rechts: ");
Serial.println(buttonPushCounter);
// Delay a little bit to avoid bouncing
delay(5);
}
}
}
if (buttonState3 == LOW) {
buttonPushCounter = 0;
}
// save the current state as the last state, for next time through the loop
lastButtonState1 = buttonState1;
lastButtonState4 = buttonState4;
}
ich habe gerade mit meinem Giga getestet. Der Datalogger Sketch von oben findet auch bei mir den USB-Stick nicht.
Das FileWrite Beispiel aus den Library Examples legt dagegen brav eine Textdatei auf dem Stick an. Dabei macht der Code zum Mounten des Sticks eigentlich nicht viel anderes.
Ich habe jetzt das Mounten des Sticks, die loop Funktion und den Device Namen aus dem FileWrite Beispiel über das DataLogger Beispiel kopiert.
Dann funktioniert alles, so wie es soll. Was eigentlich das Problem ist, habe ich aber noch nicht verstanden.
Hoffe das hilft schon mal. Hier ist der Code:
#include <Arduino_USBHostMbed5.h>
#include <DigitalOut.h>
#include <FATFileSystem.h>
USBHostMSD msd;
mbed::FATFileSystem usb("usb");
mbed::DigitalOut otg(PB_8, 1);
int err;
int count;
int number_of_readings = 500; //how many readings you want to take
int interval = 2; //how long between readings (milliseconds)
void setup() {
Serial.begin(115200);
while (!Serial);
while (!msd.connect()) {
delay(1000);
}
Serial.println("Mounting USB device...");
int err = usb.mount(&msd);
if (err) {
Serial.print("Error mounting USB device ");
Serial.println(err);
while (1);
}
Serial.print("read done ");
//function to write to file
WriteToFile();
}
//
void loop() {
delay(1000);
// handle disconnection and reconnection
if (!msd.connected()) {
msd.connect();
}
}
void WriteToFile() {
mbed::fs_file_t file;
struct dirent *ent;
int dirIndex = 0;
int res = 0;
Serial.println("Opening file..");
FILE *f = fopen("/usb/log.txt", "w+");
for (int i = 0; i < number_of_readings; i++) {
count += 1;
Serial.print("Reading Nr: ");
Serial.print(count);
Serial.print(", Value: ");
Serial.println(analogRead(A0));
fflush(stdout);
int reading = analogRead(A0);
err = fprintf(f, "%s", "Reading Nr: ");
err = fprintf(f, "%d", count);
err = fprintf(f, "%s", ", Value: ");
err = fprintf(f, "%d\n", reading);
if (err < 0) {
Serial.println("Fail :(");
error("error: %s (%d)\n", strerror(errno), -errno);
}
delay(interval);
}
Serial.println("File closing");
fflush(stdout);
err = fclose(f);
if (err < 0) {
Serial.print("fclose error:");
Serial.print(strerror(errno));
Serial.print(" (");
Serial.print(-errno);
Serial.print(")");
} else {
Serial.println("File closed");
}
}
Vielen Dank schon einmal für den Code. Jetzt funktioniert das zumindest.
Könntest du mir evtl. noch helfen wie ich es jetzt schaffe, das mein Zähler als File auf den USB kommt?
/*
Test zweigle D 315
*/
// this constant won't change:
const int buttonPin2 = 2; // hochzählen
const int buttonPin3 = 3; // Freigabe
const int buttonPin4 = 4; // Reset
const int buttonPin5 = 5; // runterzählen
// Variables will change:
int buttonPushCounter = 0; // zähler
int buttonState2 = 0; // hochzählen
int buttonState3 = 0; // Freigabe
int buttonState4 = 0; // Reset
int buttonState5 = 0; // runterzählen
int lastButtonState2 = 0;
int lastButtonState5 = 0;
void setup() {
// initialize as a input:
pinMode(buttonPin2, INPUT); // hochzählen
pinMode(buttonPin3, INPUT); // Freigabe
pinMode(buttonPin4, INPUT); // Reset
pinMode(buttonPin5, INPUT); // runterzählen
// initialize as an output:
// initialize serial communication:
Serial.begin(115200);
}
void loop() {
// digitalRead:
buttonState2 = digitalRead(buttonPin2); // hochzählen
buttonState3 = digitalRead(buttonPin3); // Freigabe
buttonState4 = digitalRead(buttonPin4); // Reset
buttonState5 = digitalRead(buttonPin5); // runterzählen
if (buttonState3 == HIGH) {
if (buttonState2 != lastButtonState2) {
if (buttonState2 == HIGH) {
buttonPushCounter++;
Serial.print("Umdrehungen: ");
Serial.println(buttonPushCounter);
delay(5);
}
}
if (buttonState5 != lastButtonState5) {
if (buttonState5 == HIGH) {
buttonPushCounter--;
Serial.print("Umdrehungen: ");
Serial.println(buttonPushCounter);
delay(5);
}
}
}
if (buttonState4 == LOW) {
buttonPushCounter = 0;
Serial.println("Reset");
delay(750);
}
lastButtonState2 = buttonState2;
lastButtonState5 = buttonState5;
}
Das eigentliche Endergebnis sollte so sein:
Ich drücke auf Start an einem Gerät. Der Motor dreht sich, bei welchem ich mit einer Lichtschranke die Umdrehungen zählen muss (linkslauf = hochzählen und rechtslauf = runterzählen) (ca. 200 Umdrehungen. Das muss ich 5x machen. Dan nach möchte ich den USB einstecken oder auch schon am Anfang und dann möchte ich in dem Textdokument wo der Arduino erstellt alle Umdrehungen haben in den 5 Läufen.
Dazu musst du nur das mounten und die Sachen zwischen FILE *f = fopen("/usb/log.txt", "w+");
und fclose(f);
aus der Vorlage @ArduFE#9 in deinen Sketch übernehmen.
Vielen dank schon einmal für die hilfreichen Antworten. Ich habe ein wenig weiter probiert komme aber irgend wie auch nicht mehr weiter.
Wenn ich den USB einstecke überspringt er meinen Zähler. Und wie schaffe ich es das wenn es einmal durchgelaufen ist nochmals funktioniert ohne es wieder neu auf den Arduino zu laden. Ich ziehe den USB Stick raus und warte. Dann stecke ich ihn wieder ein aber es funktioniert nicht mehr.
Habe es jetzt auch erst mal mit einem einfach Zähler gemacht das es etwas übersichtlicher ist.
#include <Arduino_USBHostMbed5.h>
#include <DigitalOut.h>
#include <FATFileSystem.h>
USBHostMSD msd;
mbed::FATFileSystem usb("usb");
mbed::DigitalOut otg(PB_8, 1);
// this constant won't change:
const int buttonPin2 = 2; // Freigabe
const int buttonPin3 = 3; // Reset
const int buttonPin13 = 13; // Sensor
// Variables will change:
int buttonState2 = 0; // Freigabe
int buttonState3 = 0; // Reset
int buttonState13 = 0; // Sensor
int lastButtonState13 = 0;
int count = 0; // zähler
int err;
void setup() {
// initialize as a input:
pinMode(buttonPin2, INPUT); // Freigabe
pinMode(buttonPin3, INPUT); // Reset
pinMode(buttonPin13, INPUT); // Sensor
// initialize serial communication:
Serial.begin(115200);
while (!Serial)
;
while (!msd.connect()) {
delay(1000);
}
Serial.println("Mounting USB device...");
int err = usb.mount(&msd);
if (err) {
Serial.print("Error mounting USB device ");
Serial.println(err);
while (1)
;
}
Serial.print("read done ");
//function to write to file
WriteToFile();
}
void loop() {
delay(500);
// handle disconnection and reconnection
if (!msd.connected()) {
msd.connect();
}
}
void WriteToFile() {
mbed::fs_file_t file;
struct dirent *ent;
int dirIndex = 0;
int res = 0;
Serial.println("Opening file..");
FILE *f = fopen("/usb/log.txt", "w+");
while (buttonPin2 == LOW) {
// digitalRead:
buttonState2 = digitalRead(buttonPin2); // Freigabe
buttonState3 = digitalRead(buttonPin3); // Reset
buttonState13 = digitalRead(buttonPin13); // Sensor
// Zähler
if (buttonState2 == LOW) {
if (buttonState13 != lastButtonState13) {
if (buttonState13 == HIGH) {
count++;
Serial.print("Reading Nr: ");
Serial.println("Umdrehungen: ");
Serial.println(count);
delay(5);
}
}
}
// Reset
if (buttonState3 == LOW) {
count = 0;
Serial.print("Reset: ");
Serial.println(count);
delay(750);
}
lastButtonState13 = buttonState13;
}
fflush(stdout);
err = fprintf(f, "%s", "Umdrehungen: ");
err = fprintf(f, "%d", count);
if (err < 0) {
Serial.println("Fail :(");
error("error: %s (%d)\n", strerror(errno), -errno);
}
Serial.println("File closing");
fflush(stdout);
err = fclose(f);
if (err < 0) {
Serial.print("fclose error:");
Serial.print(strerror(errno));
Serial.print(" (");
Serial.print(-errno);
Serial.print(")");
} else {
Serial.println("File closed");
}
}
Irgend wie blicke ich nicht mehr durch.
Ich schaffe es nicht, das ich meinen Eingang zähle und dann den USB einstecke und die Umdrehungen dann auf den USB geschrieben werden.
Entweder geht gar nichts oder er schreibt erst ein leeres Dokument und dann kann ich zählen.
Gibt es nochmals irgend welche Tipps wo ich probieren könnte?
Das Beispiel setzt voraus, dass der Stick von Anfang an drin steckt und auch da bleibt.
Wenn er zwischendurch hinein kommt, wird der Code viel komplexer. Dann musst du deine Daten erst mal woanders zwischenspeichern und dann auf den Stick kopieren. Wobei man beim Schreiben auch noch schauen muss, ob er zwischenzeitlich nicht wieder verschwindet.
Ich habe das ganze USB Stick Thema nun verworfen und bin anders zu meinem Ziel gekommen.
Jetzt habe ich allerdings ein anderes Problem und zwar möchte ich 6 Zähler in einem Sketch haben. Ist sowas möglich? Also wenn Eingang 8 High ist soll Zähler 1 zählen und wenn Eingang 9 High ist soll Zähler 2 zählen usw..
Irgend wie zählt bei mir immer Zähler 1 hoch. Wo könnte da der Fehler sein?
/*
Zähler 6-fach
*/
// Variables will change:
int buttonState2 = 0; // Sensor
int buttonState4 = 0; // Reset
int buttonState8 = 0; // Zähler 1 Freigabe
int buttonState9 = 0; // Zähler 2 Freigabe
int lastButtonState2 = 0;
int counter1 = 0; // Zähler 1
int counter2 = 0; // Zähler 2
void setup() {
// initialize as a input:
pinMode(2, INPUT); // Sensor
pinMode(4, INPUT); // Reset
pinMode(8, INPUT); // Zähler 1 Freigabe
pinMode(9, INPUT); // Zähler 2 Freigabe
// initialize as an output:
// initialize serial communication:
Serial.begin(9600);
}
void loop() {
// digitalRead:
buttonState2 = digitalRead(2); // Sensor
buttonState4 = digitalRead(4); // Reset
buttonState8 = digitalRead(8); // Zähler 1 Freigabe
buttonState9 = digitalRead(9); // Zähler 2 Freigabe
// Zähler 1
if (buttonState8 == HIGH && (buttonState2 != lastButtonState2)) {
if (buttonState2 == HIGH) {
counter1++;
Serial.print("Zähler 1: ");
Serial.println(counter1);
}
}
lastButtonState2 = buttonState2;
if (buttonState8 == HIGH && buttonState4 == LOW) {
counter1 = 0;
Serial.println(counter1);
delay(750);
}
// Zähler 2
if (buttonState9 == HIGH && (buttonState2 != lastButtonState2)) {
if (buttonState2 == HIGH) {
counter2++;
Serial.print(",");
Serial.print("Zähler 2: ");
Serial.println(counter2);
}
}
lastButtonState2 = buttonState2;
if (buttonState9 == HIGH && buttonState4 == LOW) {
counter2 = 0;
Serial.println(counter2);
delay(750);
}
}