Mein Studienkolleg und ich sind gerade daran, ein geschwindigkeitsmesser für das Fahrrad mit einem Arduino MKR1000 zu bauen.
Als Zusatz möchten wir die gefahrene Geschwindigkeit, welche auf unserem LCD-Display angezeigt wird, auf dem Webinterface des Arduinos anzeigen lassen.
Hier unser Code für den Geschwindigkeitsmesser:
#include <PCD8544.h> //Es wird die Bibliothek für das Display eingebunden
static PCD8544 lcd; //Die statische Variable "PCD8544 lcd" wird definiert.
int irqPin = 2; //Der Interrut befindet sich auf digitalen Pin 0.
//Mit dem Interrupt wird der HALL-Sensor angeschlossen.
// https://www.arduino.cc/reference/en/language/functions/external-interrupts/attachinterrupt/
float umdreh; //Definition von der Variable "umdreh". Ihr wird der Datentyp "float" zugewiesen.
//Die Variable ermittelt, wie lange eine Umdrehung dauert.
float anz; //Definition der Variable "anz". Ihr wird der Datentyp "float" zugewiesen.
//Die Variable dient dazu, die Anzahlumdrehungen zu speichern.
float rpm; //Definition der Variable "rpm". Ihr wird der Datentyp "float" zugewiesen.
//Die Variable dient dazu, den Radius des Rades zu erfassen.
float spd; //Definition der Variable "spd". Ihr wird der Datentyp "float" zugewiesen.
//Die Variable dient dazu, die gefahrene Geschwindigket zu erfassen.
float dist; //Definition der Variable "dist". Ihr wird der Datentyp "float" zugewiesen.
//Die Variable dient dazu, die gefahrene Distanz zu erfassen.
//Diese Variablen werden für die Berechnung und Speicherung der einzelne //Geschwindigkeitsberechnungswerte verwendet.
unsigned long timeold; //Definition der Variable "timeold".
//Ihr wird der Datentyp "unsigned long" zugewiesen.
//Die Variable wird zur Zeitmessung verwendet.
//Die Geschwindigkeit basiert immer auf der Messung von Distanz pro Zeiteinheit.
float WHEELCIRC = 2.0736; //(2* PI*0.3302 in m)
//Definition der Variable "WHEELCIRC". Ihr wird der datentyp "float" zugewiesen.
//Die Variable bestimmt den Umfang des Rades.
//2*PI*r=>Umfang von einem Kreis
void setup() //Das Setup beginnt
{
Serial.begin(9600); //Initialisierung der seriellen Schnittstelle mit der Baudrate 9600.
//Interrupt
digitalWrite(irqPin, HIGH);
//Der Interrupt wird mit einem Pullup-Widerstand angesteuert.
//Der Interrupt wird bei fallender Flanke aktiviert.
// Funktion "count_umd" wird aufgerufen.
attachInterrupt(0, count_umd, FALLING);
lcd.begin(84, 48); //Initialisierung des LCD-Displays
lcd.setCursor(0, 0); //Setzen des Cursors vom LCD-Displays auf 0.
lcd.print("BIKESPEED V1"); //Auf dem LCD-Display wird "BIKESPEED V1" ausgegeben
umdreh = 0; //Die Variable "umdreh" wird mit 0 initialisiert.
rpm = 0; //Die Variable "rpm" wird mit 0 initialisiert.
timeold = 0; //Die Variable "timeold" wird mit 0 initialisiert.
dist=0; //Die Variable "dist" wird mit 0 initialisiert.
} //Alle Variablen werden mit 0 Initalisiert, weil der Startzustand nicht bekannt ist.
//So gibt es einen sauberen Start.
void loop() //Die Hauptschleife des Programms beginnt.
{
lcd.setCursor(0, 0); //Der Cursor des LCD-Displays wird auf die Position 0 gesetzt.
lcd.print("BIKESPEED V1"); //Auf dem LCD-Display wird "BIKESPEED V1" ausgegeben
if (umdreh >=3) //Es wird geprüft, ob die Anzahl Umdrehungen >=3 ist.
//Wenn ja, startet die Berechnung "timediff=millis()-timeold
{
int timediff=millis()-timeold;
/*
Zuerst wird die Zeitdifferenz der letzten Berechnung ermittelt.
Anschliessend wird der ermittelte Wert in die Variable "timediff" gespeichert.
Die Zeitdifferenz kann aus der Geschwindigkeit oder der Umdrehung berechnet werden.
*/
rpm = anz/timediff;
/*
Hier wird die Umdrehungsgeschwindigkeit berechnet.
Diese wird mittels Multiplikation mit dem Radumfang ermittelt.
*/
spd = (rpm *WHEELCIRC * 3600);
/*
In diesem Schritt wird die Geschwindigkeit in km/h ermittelt.
Dies wird durch Multiplikation mit dem Umfang und 3600 ermittelt.
*/
dist = dist + (anz * WHEELCIRC);
*/
In diesem Schritt wird die zurückgelegte Distanz berechnet
Dies geschieht durch Addition der zurückgelegten Strecke während der letzten Messphase.
Dies wiederum errechnet sich aus den Anzahl Umdrehungen des Reifens* des Radumfangs
*/
//Die ermittelten Werte werden zur Kontrolle im seriellen Monitor ausgegeben.
Serial.print("Speed: "); //Ausgabe der Geschwindigkeit
Serial.print(spd,1);
Serial.println(" km/h"); //Ausgabe der Geschwindigkeit in km/h
Serial.print("Distance: ");
Serial.print(dist/1000,3);
Serial.println(" m"); //Ausgabe der gefahrenen Diestanz in Meter
timeold = millis(); //millis() gibt die Zeit in millisekunden seit Start des Programmes zurück.
//Beispiel dazu: https://www.arduino.cc/reference/en/language/functions/time/millis/
//In diesem Fall wird der Wert in die Variable "timeold" gespeichert.
//millis() – zimeold = verstrichene Zeit zwischen 2 Messungen.
umdreh = 0; //Die Variable "umdreh" wird auf den Wert 0 gesetzt.
}
//Die berechneten Werte für die Geschwindigkeit und Distanz werden auf dem LCD-Display dargestellt:
lcd.setCursor(0, 1); //Setzen des Cursors mit den Positionen 0 und 1.
lcd.print("G: ");
lcd.setCursor(20, 1); //Setzen des Cursors an die Position 20 und 1.
lcd.print(spd,1); //Der Wert von der Variable "spd" wird an Position 1 ausgegeben.
lcd.setCursor(50, 1); //Der Cursor wird auf die Position 50 und 1 gesetzt
lcd.print("(km/h)"); //Die Geschwindigkeit wird in km/h ausgegeben. Die erste Geschwindigkeit.
lcd.setCursor(0, 2); //Der Cursor wird an die Position 0 und 2 gesetzt.
lcd.print("D: "); //Die gefahrene Distanz wird in Metern ausgegeben.
lcd.print(dist/1000,3); //Die gefahrene Distanz wird in Metern umgerechnet.
//An Position 3 soll sie ausgegeben werden.
lcd.setCursor(50, 2); //Die Cursor wird auf Position 50 und2 gesetzt.
lcd.print("(km/h)"); //Die Geschwindigkeit wird erneut in km/h ausgegeben. Die zweite Geschwindigkeit
}
void count_umd() //Die Funktion "count_umd" wird definiert und ohne Rückgabewert.
{
umdreh=umdreh+1;
anz=umdreh;
}
/*
"count_umd()" wird dann aufgerufen, wenn der HALL-Sensor ein Signal empfängt.
Der Funktionsaufruf erfolgt jeweils mittels der Interrupt-Funktion "attachinterrupt()".
Der Interrupt 0 ist auf Pin 0 angeschlossen.
Nach Aufruf der Funktion "count_umd()" wird der Wert für die Umdrehung um 1 erhöt.
*/
Und hier ist der Code um das WLAN-Modul anzusteuern:
#include <SPI.h> //Einbinden der SPI-Bibliothek.
#include <WiFi101.h> //Einbinden der WiFi101.h Bibliothek.
#define SECRET_SSID "Blubb"
//Definition der SSID.
#define SECRET_PASS "12345678"
//Definition des WLAN-Passworts.
char ssid[] = SECRET_SSID; // Definiton des Arrays "ssid". Ihm wird der Datentyp "char" zugewiesen
char pass[] = SECRET_PASS; //Definition des Arrays "pass". Ihm wird der Datentyp "char" zugeordnet.
//Diese beiden Arrays diesenen dazu, später im Code auf die SSID und das
//Passwort zuzugreifen
int keyIndex = 0; //Definition der Variable "keyIndex". Ihr wird der Datentyp "int" zuegwiesen.
//Sie wird mit 0 initialisiert.
//Sie ist die Netzwerk-Schlüssel-Index-Nummer.
//Dies wird alleridngs nur in Gebrauch mit WEP verwendet.
int status = WL_IDLE_STATUS;
//Definition der Variable "status". Ihr wird der Datentyp "int" zugewiesen.
//Die Variable liefert den aktuellen Status des WLANs.
WiFiServer server(80); //Der Port 80 wird als Kommunikationsport verwendet
void setup() //Das Setup wird gestartet
{
Serial.begin(9600); //Initialisierung der seriellen Schnittstelle mit der Baudrate 9600
pinMode(9, OUTPUT); //Definition des Pin 9 als Output. Später für eine LED.
if (WiFi.status() == WL_NO_SHIELD)
//Die Verfügbarkeit des WLAN-Shields wird überprüft.
//Wenn es nicht verfügbar ist, wird dies auf dem seriellen Monitor ausgegeben.
{
Serial.println("WiFi shield not present");
//Die Ausgabe lautet: "WiFi ist nicht verfügbar".
while (true); //Es wird solange keine weitere Aktion ausgeführt,
//wie das WiFi-Shield nicht verfügbar ist.
}
//Es wird weiter versucht, sich mit dem WLAN-netzwerk zu verbinden.
while ( status != WL_CONNECTED)
//Solange keine Verbindung mit dem WiFi-Shield besteht,
//wird folgendes auf dem seriellen Monitor ausgegeben:
{
Serial.print("Attempting to connect to Network named: ");
//Die Ausgabe lautet:
//"Es wird versucht, sich mit dem Netzwerk namens: " zu verbinden
Serial.println(ssid); //Der Name des Netzwerkes (SSID) wird ausgegeben
// Anschliessend wird mit WPA/ WPA2 mit dem Netzwerk verbunden.
//Wird WEP als Verschlüsselung verwendet,
//kann dieser Schritt übersprungen werden
status = WiFi.begin(ssid, pass);
delay(10000); //Es wird 10 Sekunden gewartetm, bis die Verbindung aufgebaut wird.
}
server.begin(); //Der Webserver wird auf Port 80 gestartet.
printWiFiStatus(); //Die Verbindung zum Netzwerk ist hergestellt. Der Status wird ausgegeben,
}
void loop() //Die Hauptschleife des Programmcodes wird gestartet.
{
WiFiClient client = server.available();
//Es wird kontrolliert, ob sich Clients am Netzwerk anmelden möchten
if (client) //Wenn sich Clients verbinden wollen,
//wird dies auf dem seriellen Monitor ausgegeben:
{
Serial.println("new client"); //Die Ausgabe lautet: "Neue Clients"
String currentLine = " "; //Es wird auf einen ankommenden String von Daten gewartet
//welche von den Clients gesendet werden.
while (client.connected()) //Solange Clients mit dem Netzwerk verbunden sind wird folgendes gemacht:
{
if (client.available()) //Wenn Bytes von den Clients gelesen werden können:
{
char c = client.read(); //Wird ein Byte eingelesen und anschliessend am seriellen Monitor ausgegeben.
Serial.write(c); //Dies wird anschliessend im seriellen Monitor ausgegeben.
if (c == '\n') { //Wenn es sich bei dem Byte um ein "newline character" handelt,
//wird folgendes gemacht:
//Wenn die jetzige Linie leer ist, dann werden zwei neue Linien Charaktere
//in einer Reihe gemacht
//Damit ist der http-Request des Clients beendet.
//Schicke anschliessend eine Rückmeldung:
if (currentLine.length() == 0)
//Wenn die aktuelle Linien länge = 0 ist, wird folgendes gemacht:
{
//Ein HTTP-Headers startet immer mit einem Rückmelde-Code.
//Zum Beispiel: HTTP/1.1 200 OK
//Anschliessend folgt der Inhalts-Typ. Dadurch weiss der Client,
//was ihn erwartet. Anschliessend wird eine leere Linie gemacht:
client.println("HTTP/1.1 200 OK");
//Der http-request war ok.
client.println("Content-type:text/html");
client.println(); //Dies wird anschliessend auf dem seriellen Monitor ausgegeben
//Der Inhalt der http-Rückmeldung ist gleich dem Header:
client.print("Click <a href=\"/H\">here</a> turn the LED on pin 9 on
");
client.print("Click <a href=\"/L\">here</a> turn the LED on pin 9 off
");
//Die http-Rückmeldung endet mit einer erneuten leeren Linie:
client.println();
//"Ausbruch" aus der While-Schleife:
break;
}
else
{ // Wenn eine Neuelinie kommt, dann mache die Momentane Linie frei:
currentLine = ""; //Wird eine Neulinie generiert, wird die aktuelle Linie frei gemacht
}
}
else if (c != '\r') //Wenn ein Transport Carakter vorhanden ist, wird ein Charakter zurück gegeben
{
currentLine += c; //Anschliessend wird dies an das Ende der momentanen Linien hinzugefügt
}
//Nun wird überprüft, ob die Anfrage des Clients "GET /H" oder "GET /L" ist:
//Es wird auf GET oder POST überprüft
if (currentLine.endsWith("GET /H"))
//Im Falle einer GET H:
{
digitalWrite(9, HIGH); //Die LED in Pin 9 wird eingeschaltet. Pin 9 wurde zuvor als Output definiert.
}
if (currentLine.endsWith("GET /L"))
//Falls es ein GET L ist,
{
digitalWrite(9, LOW); //Die LED an Pin 9 wird ausgeschaltet.
}
}
}
//Deaktivieren der WLAN-Verbindung
client.stop(); //Der Client wird aus der Verbindung rausgeworfen.
Serial.println("client disonnected");
//Dies geschieht nur, wenn der Client die Verbindung trennt.
//Im seriellen Monitor lautet die Ausgab: "Der Client hat die Verbindung getrennt.
}
}
void printWiFiStatus() {
Serial.print("SSID: "); //Die SSID wird ausgegeben, mit welcher sich der Client zuvor verbunden hat.
Serial.println(WiFi.SSID());
IPAddress ip = WiFi.localIP(); //Die IP-Adresse vom WLAN-Modul des MKR1000 wird ausgegeben.
Serial.print("IP Address: "); //Die Ausgabe lautet: "IP-Adresse: "
Serial.println(ip);
long rssi = WiFi.RSSI(); //Die Signalstärke des WLANs wird ausgegeb:
Serial.print("signal strength (RSSI):");
Serial.print(rssi);
Serial.println(" dBm");
Serial.print("To see this page in action, open a browser to http://");
//Die serielle Ausgabe lautet: "Um sich auf den Arduino MKR1000 zu verbinden,
//gib in deinem Browser ein: http:// "
//Anschliessend wird die IP-Adresse des MKR100 dargestellt
Serial.println(ip); //Die IP-Adresse des MKR1000 wird ausgegeben
}
Und nun?
Weder eine Vorstellung, welche Schritte Ihr unternehmen wollt, um an Euer Ziel zu gelangen, noch auch nur ein Hauch an Eigeninitiative drängen sich mir ins Blickfeld.
Soll Das so?
Also heutiges Studentenvolk fragt in irgend einem Forum nach Code-Spenden für eine bessere Note?
Dann: Gute Nacht, Deutschland!
MfG
PS: War 'studieren' nicht 'sich selbst beibringen' ??