Fahrrad-Computer

Diese Anleitung beschreibt einen Fahrrad-Computer. Auf einem OLED-Display werden Geschwindigkeit, Durchschnitts-Geschwindigkeit, Fahrzeit und Gesamtstrecke angezeigt. Mit einem Drehwinkelgeber werden die Seiten am Display ausgewählt. Auf Knopfdruck (Drehwinkelgeber) können die Werte gelöscht werden.

Hardware

Die Stückliste für den Fahrrad-Computer:

• 1 x NANO
• 1 x Drehwinkelgeber KY-040
• 1 x OLED-Display SSD1306, 128x64 Pixel
• 1 x Hall-Sensor-Modul KY-024
• 1 x Speichenmagnet
• 1 x 9-V-Batterie inklusive Batterieclip
• 3 x Kunststoffgehäuse (ca. 2,5 cm x 3,5 cm x 6 cm)
• Kleinmaterial, Kabelbinder, Klemmen, Schaltdraht

Verdrahtung

NANO - Drehwinkelgeber KY-40:

		NANO		KY40
		GND		GND
		+5V		+5V
		D5		SW
		D4		DT
		D3		CLK

NANO - Hall-Sensor-Modu KY-024:

		NANO		KY-024
		GND		GND
		+5V		+5V
		D2		D0

NANO - 9V-Batterie:

		NANO		9V
		GND		GND
		Vin		+5V

Software

Die Software wird mit der Arduino IDE in den NANO geladen.

• Nach dem Programm-Download in den NANO
• werden die Seiten am Dsplay angezeigt
• und können mit dem Drehwinkelgeber durchgeblättert werden.

Programm

C++ Code:

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: Fahrradcomputer mit Drehgeber, Hallgenerator und SSD1306 Display
**************************************************************************************************
Version: 26.07.2021
**************************************************************************************************
Board: Arduino NANO
**************************************************************************************************
C++ Arduino IDE V1.8.13
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
**************************************************************************************************/

#define RADUMFANG     211   // Radumfang in cm

#define HALL_SENSOR   2     // muss Interrupt-fähig sein
#define ENCODER_CLK   3     // muss Interrupt-fähig sein
#define ENCODER_DT    4
#define ENCODER_SW    5

#include "Wire.h"
#include "Adafruit_SSD1306.h"
Adafruit_SSD1306 Display(128, 64);      // Übergabe der Display-Breite und -Höhe

byte Modus = 11;
volatile byte EncoderStatus = 200;
volatile unsigned long RadSensor_Zeit = 0;
unsigned long Umdrehungen = 0;
unsigned long LetzteWerte[] = {0,0,0,0,0,0,0,0,0,0};
byte LetzteWerte_Index = 0;
unsigned long LetzteWerte_Timer = 0;
unsigned long aktivSekunden = 0;
unsigned long Knopfdruck = 0;
boolean BlinkIndikator = false;

void setup()
{
  pinMode(ENCODER_DT, INPUT_PULLUP);
  pinMode(ENCODER_CLK, INPUT_PULLUP);
  pinMode(ENCODER_SW, INPUT_PULLUP);
  pinMode(HALL_SENSOR, INPUT);
  pinMode(7, OUTPUT);
  digitalWrite(7, LOW);

  Display.begin(SSD1306_SWITCHCAPVCC, 60);  // Display-Verbindung initialisieren
                                            // (mit Standard-I²C-Adresse 60)
  Display.setTextColor(WHITE);
  Display.clearDisplay();

  attachInterrupt(digitalPinToInterrupt(ENCODER_CLK), Encoder, RISING);
  attachInterrupt(digitalPinToInterrupt(HALL_SENSOR), UmdrehungZaehlen, RISING);
}

void loop()
{
  Display.clearDisplay();
  Display.setTextSize(1);

  Display.fillRect(122,58,127,63, BlinkIndikator ? WHITE: BLACK);

  if(Modus == 11)         // aktuelle Geschwindigkeit
  {
      Display.setTextSize(1);
      Display.setCursor(0,0);
      Display.print("aktuelle");
      Display.setCursor(0,10);
      Display.print("Geschwindigkeit  km/h");
      Display.setTextSize(4);
      Display.setCursor(0,30);
      long Umdrehungen10s = LetzteWerte[LetzteWerte_Index] -
          LetzteWerte[(LetzteWerte_Index+1)%10];
      float Weg10s = Umdrehungen10s * RADUMFANG / 100.0;
      float kmh = Weg10s * 360.0/1000.0;
      Display.print(kmh);
  }

  if(Modus == 12)         // Durchschnittsgeschwindigkeit
  {
      Display.setTextSize(1);
      Display.setCursor(0,0);
      Display.print("Durchschnitts-");
      Display.setCursor(0,10);
      Display.print("Geschwindigkeit  km/h");
      Display.setTextSize(4);
      Display.setCursor(0,30);

      long Gesamtstrecke = Umdrehungen * RADUMFANG;         // in cm
      float kmh_ges = Gesamtstrecke * 3.6 / (aktivSekunden*100.0);
      Display.print(kmh_ges);
  }

  if(Modus == 13)         // Strecke
  {
      Display.setTextSize(1);
      Display.setCursor(0,0);
      Display.print("Gesamtstrecke      km");
      Display.setTextSize(4);
      Display.setCursor(0,30);
      float km = Umdrehungen * RADUMFANG / 100000.0;
      Display.print(km);
  }

  if(Modus == 14)         // aktive Zeit
  {
      Display.setTextSize(1);
      Display.setCursor(0,0);
      Display.print("aktive Zeit      m:s");
      Display.setTextSize(4);
      Display.setCursor(0,30);
      Display.print(aktivSekunden/60);
      Display.print(":");
      if(aktivSekunden%60 < 10)
        Display.print("0");
      Display.print(aktivSekunden%60);
  }

  Knopfdruck = millis();
  while(!digitalRead(ENCODER_SW))         // Zurücksetzen
  {
      Display.clearDisplay();
      Display.setTextSize(2);
      Display.setCursor(0,0);
      Display.print("Loeschen?");

      if(millis() - Knopfdruck > 3000)      // nach 3 Sekunden
      {
        Display.setCursor(30,30);
        Display.print("Ok!");
        Umdrehungen = 0;
        aktivSekunden = 0;
        for(byte i = 0; i < 10; i++)
          LetzteWerte[i] = 0;
      }

      Display.display();
  }

  Display.display();

                                  // Umdrehung detektiert?
  if(millis() - RadSensor_Zeit > 50 && RadSensor_Zeit != 0)
  {
    if(!digitalRead(HALL_SENSOR))
    {
      Umdrehungen++;
      BlinkIndikator = !BlinkIndikator;
    }
    RadSensor_Zeit = 0;
  }


  if(EncoderStatus != 200)          // wurde der Encoder bewegt?
  {
    if(EncoderStatus & B00010000)
      Modus++;
    else
      Modus--;
    EncoderStatus = 200;
  }
  if(Modus > 14)
    Modus = 11;
  if(Modus < 11)
    Modus = 14;


  if(millis() > LetzteWerte_Timer)  // jede Sekunde aktuelle Umdrehungszahl speichern
  {
    LetzteWerte_Index = (LetzteWerte_Index + 1) % 10;
    LetzteWerte[LetzteWerte_Index] = Umdrehungen;
    LetzteWerte_Timer = millis() + 1000;

    if(LetzteWerte[LetzteWerte_Index] != LetzteWerte[(LetzteWerte_Index+1)%10])
      aktivSekunden++;              // aktive Zeit zählen
  }
}

void Encoder()
{
  EncoderStatus = PIND;   // D-Register enthält auch Pin D4 (DT-Pin des Encoders), dieser gibt Aufschluss über die Drehrichtung
}

void UmdrehungZaehlen()
{
  RadSensor_Zeit = millis();
}

RAW code

Testaufbau:

Display-Anzeigen:

Gehäuse mit Halterung und Deckel:

OpenScad Boxbuilder

Fahrrad-Computer Gehäuse (STL)

nach oben