Kettenöler

Viele, die ein Motorrad ihr eigen nennen, dessen Antrieb mit einer Kette umgesetzt ist, haben sicher schon einmal mit einem automatischen Ölsystem geliebäugelt und möglicherweise darüber nachgedacht, so etwas im Eigenbau zu realisieren.

Um es gleich vorwegzunehmen, es gibt hier im Non-Profit-Bereich ein ausgefuchstes und über Jahre an vielen Maschinen erprobtes System („Rehoiler“), das kaum Wünsche offen lässt. Bestelllisten, Bauanleitungen, Einbaubeispiele und Unterstützung vom Betreiber der Internetpräsenz und weiteren Fachkundigen sind bei der Umsetzung eines solchen Projekts verfügbar, sodass der Eigenbau mit etwas handwerklichem Geschick gelingen sollte.

Leute, die solche Do-it-yourself-Projekte angehen, machen das vermutlich aus zwei Gründen: Einerseits versprechen sie sich Vorteile aus dem Nutzen des zu erstellenden Objekts, andererseits treibt sie aber auch die Neugierde (der Wissensdurst): Was zusammengebaut wird, soll auch gedanklich durchdrungen sein.

In dem Rehoiler-Projekt wird vieles, aber leider nicht alles aufgeklärt. Während bei der zu verwendenden Hardware kaum Fragen offen bleiben, wird der Programmcode nur in binärer Form verfügbar gemacht. Er ist damit für Normalsterbliche nicht lesbar. Auch werden die Werkzeuge (USBasp mit Adapter für den ATmega168 und die Software „my AVR ProgTool“) zur Übertragung des Binärcodes nur in Teilen erläutert. Stattdessen wird empfohlen, einen fertig programmierten Controller vom Entwickler zu beziehen.

Aus den letztgenannten Umständen ist die Idee geboren, einen eigenen Öler zu entwickeln mit dem Ziel, Einblicke in dessen Funktionsweise und damit zusammenhängende Fragen bei der Programmierung gewinnen zu können.

Und das ist der Plan im Überblick:

Der Öler soll mit einer Ölpumpe arbeiten, die mithilfe der Elektronik nach einer bestimmten Wegstrecke eine voreingestellte Menge Öl aus einem Vorratstank zur Kette befördert. Zur Bestimmung der zurückgelegten Strecken wird ein Reedkontakt benutzt, der – ausgelöst von einem Magneten am hinteren Kettenblatt – bei jeder Radumdrehung ein Signal erzeugt.
Zudem soll für Regenfahrten über einen Schalter die Ölmengen dauerhaft erhöht werden können. Weiterhin sollen über einen Taster jederzeit zusätzliche Ölgaben ausgelöst werden können.
Zur Überprüfung der Funktionstüchtigkeit des Steuermoduls soll eine 3mm LED Leuchtsignale ausgeben: Beim Einschalten der Zündung soll sie 10 Sekunden lang angehen und kurz bei jedem Kolbenhub der Pumpe.

Das Steuermodul bekommt Strom aus dem Bordnetz, hier der Zuleitung zum Rücklicht, das beim Einschalten der Zündung angeht.
Die Steuerung selbst soll ein Arduino Nano übernehmen, mit dem das Modul klein gehalten werden kann. Das folgende Bild zeigt rechts den Eigenbau (6 x 4,5cm) im Größenvergleich mit der Steuerplatine IQ11 des oben genannten Rehoilers (in der Abbildung links).

Im Eigenbau befindet sich auf der Lochrasterplatine rechts ein Spannungswandler, der die Bordspannung des Motorrads von 12 auf 5V runterregeln soll, in der Mitte die Entwicklerplatine (Arduino Nano) mit einem ATmega328p und einem Mikro-USB-Anschluss für die Programmierung und links ein programmierbarer Schalter zum Steuern der Ölpumpe.

Hier der dazugehörige Schaltplan:

Es ist zu hoffen, dass die Schaltung in den Augen von Experten Gnade findet. Besonders an den Kondensatoren steht ein Fragezeichen.

Und nach der folgenden Vorlage kann der Aufbau hoffentlich gelingen:

Hier ein Programmcode, der die geplanten Funktionen auslösen kann:

/* LED: > 10 Sekunden Dauerlicht nach Einschalten der Zündung => Betriebsbereitschaft der Elektronik
 *      > kurzes Aufleuchten => Pumpimpuls
 * Schalter "on":   > Vermehrte Öldosierung
 * Schalter "off":  > Normale Öldosierung
 * Taster gedrückt halten:  > Dauerpumpen (LED blinkt)
 */
int pumpe_pin = 3; // Von hier kommt das Signal zum Anschalten der Pumpe
int const reed_pin = 2; // Hier läuft das Signal vom Reedkontakt auf
int const reed_pin_interrupt = 0; /* Einrichten eines Interrupts,
  um die Signale des Reedkontakts verarbeiten zu können.*/
int rain_pin = 8; // Regenschalter
int dauerpump_pin = 9; // Taster, um Dauerpumpen auslösen zu können
int LED = 7;

void setup() {
  Serial.begin(9600);
  Serial.println("Ereigniszaehler");
  pinMode(reed_pin, INPUT_PULLUP);
  pinMode(rain_pin, INPUT_PULLUP);
  pinMode(dauerpump_pin, INPUT_PULLUP);
  pinMode(pumpe_pin, OUTPUT);
  pinMode(LED, OUTPUT);

  // LED beim Starten 10 Sekunden lang leuchten lassen
  digitalWrite(LED, HIGH);
  delay(10000);
  digitalWrite(LED, LOW);

  //Interrupt aufrufen und Reedsignale zählen in aufsteigender Reihenfolge.
  attachInterrupt(reed_pin_interrupt, counter, RISING);
}

static int events = 0; //Die Variable "events" definieren und auf 0 setzen

//Die Zählroutine einrichten
void counter() {
  ++events;

  Serial.print("Events: "); Serial.println(events);
  if (events <= 750) { //Unter einer bestimmten Zahl von Reedsignalen ...
    digitalWrite(pumpe_pin, LOW); //... bleibt die Pumpe aus.
  }
}
//Vorgänge, die sich dauerhaft wiederholen müssen
void loop() {
  //Immer wenn eine bestimmte Zahl von Signalen erreicht und der Regenschalter ausgeschaltet("LOW" --> INPUT_PULLUP)ist ...
  if ((digitalRead(rain_pin) == HIGH ) && (events > 50)) {
    for (int zaehler = 1; zaehler < 4; zaehler = zaehler + 1) { // ... wiederhole 3 mal ...
      digitalWrite(pumpe_pin, HIGH); digitalWrite(LED, HIGH); // ... an ...
      delay(250);
      digitalWrite(pumpe_pin, LOW); digitalWrite(LED, LOW); // ... aus ....
      delay(250);
    }
    events = 0; // ... und setze danach den Ereigniszähler auf 0.
  }
  //Immer wenn eine bestimmte Zahl von Signalen erreicht und der Regenschalter eingeschaltet("LOW" --> INPUT_PULLUP)ist ...
  if (digitalRead(rain_pin) == LOW && (events > 75)) {
    for (int zaehler = 1; zaehler < 7; zaehler = zaehler + 1) { // ... wiederhole 6 mal ...
      digitalWrite(pumpe_pin, HIGH); digitalWrite(LED, HIGH); // ... an ...
      delay(250);
      digitalWrite(pumpe_pin, LOW); digitalWrite(LED, LOW); // ... aus ...
      delay(250);
    }
    events = 0; // ... und setze danach den Ereigniszähler auf 0.
  }
  //Wenn Dauerpumpen eingeschaltet("LOW" --> INPUT_PULLUP)ist ...
  if (digitalRead(dauerpump_pin) == LOW) {
    digitalWrite(pumpe_pin, HIGH); digitalWrite(LED, HIGH);// ... an ...
    delay(250);
    digitalWrite(pumpe_pin, LOW); digitalWrite(LED, LOW);// ... aus ...
    delay(250);
  }
}

Damit überprüft werden kann, ob der Code auch tut was er soll, wird folgender Testaufbau vorgeschlagen:

Dazu die passende Schemazeichnung:

Bleibt noch zu erwähnen, dass die Pumpimpulse viel zu kurz gewählt sind und nicht dem entsprechen, was bei einer realen Fahrt voreingestellt sein müsste.

Viel Spaß beim Ausprobieren!