Bikey: Arduino-Fahrradalarmanlage mit RFID-Sicherung im Eigenbau

Gute preisgünstige Fahrradalarmanlage gibt es nicht. Warum also nicht einfach eine Alarmanlage selber bauen? Rund 40 Euro kosten die Bauteile für ein System auf Basis eines Arduino Mini Pro, das man per RFID aktiviert oder abstellt.

Das Konzept

Bei der Suche nach Fahrradalarmanlagen findet man entweder billigen Plunder aus Fernost oder kompliziert zu installierende und bedienende Systeme für horrendes Geld. Meine Vorstellungen von einer Fahrradalarmanlage erfüllt keine der angebotenen Lösungen. Dabei sind meine Anforderungen nicht besonders hoch: Die kompakte und kostengünstige Alarmanlage sollte sicher sein, sich unkompliziert aktivieren und ausschalten lassen sowie eine akustische und optische Warnung ausgeben. Damit man nicht ständig Batterien wechseln oder Akkus laden muss, sollte sie energiesparend arbeiten. Da es nichts Vergleichbares gibt, kommt nur ein Eigenbau in Frage. Der Arduino Mini Pro bietet dazu mit seinen vielen Anschlussmöglichkeiten sowie üppigen Programmspeicher und dynamischen Speicher für Variablen die optimale Basis. Verschiedene Module für RFID, Lageerkennung und Signalausgabe sind reichlich vorhanden und lassen sich problemlos anschließen und kombinieren. Ein Name hat das Projekt auch: Bikey, eine Kombination aus Bike für Fahrrad und Key für Schlüssel.

Power-Schalter und Stromversorgung

Um nicht unnötig Strom zu verbrauchen, muss Bikey nur dann eingeschaltet sein, wenn die Alarmanlage benötigt wird. Ein einfacher wasser- und staubdichter Wippschalter erledigt diesen Job.

Gespeist wird die Alarmanlage über eine Powerbank im Kreditkartenformat. Das preisgünstige Modell Amazon Basics verfügt mit 2000 mAh über genügend Kapazität, um einen Arduino Mini Pro und die restlichen Komponenten mit ausreichend Strom zu versorgen. Der Stromspender liefert eine Spannung von rund 5 Volt und hält im scharf geschaltetem Zustand etwa 26 Stunden durch. Reicht das nicht, muss man einen leistungsfähigeren Akku verwenden. Aufgeladen wird die Powerbank über eine nach außen geführte Micro-USB-Buchse.

Scharfschalten per RFID

Bikey schaltet man mit einen RFID-Tag über einen RFID-Reader scharf, den der Arduino Mini Pro über die SPI-Outputs 10 (SS), 11 (MOSI), 12 (MISO) und 13 (SCK) sowie 9 (RST) ansteuert.

Das verwendete RFID-Modul benötigt zwingend eine Spannung von 3,3 Volt, bei 5 Volt raucht das Modul auf. Ein zwischengeschalteter 3,3-V-Spannungsregler und zwei Sieb-Kondensatoren bringen die vorhanden 5 Volt Spannung auf das gewünschte Niveau.

Das Auslesen der individuellen ID eines RFID-Tags ist etwas trickreich, weil die vier Blöcke der ID einzeln ausgelesen werden müssen. Als Tags kommen ein RFID-Schlüsselanhänger und eine RFID-Karte zum Einsatz. Falls der Tag verloren oder kaputt geht, hat man immer noch die Karte in Reserve.

Ein Relais überbrückt beim Scharfschalten den manuellen Ein-Aus-Schalter. So kann ein Dieb die Anlage nicht einfach abschalten. Nach dem Entschärfen ist die Überbrückung wieder aufgehoben und die Alarmanlage kann über den Wippschalter vom Strom getrennt werden.

Betriebszustandsanzeige

Eine RGB-LED zeigt den Betriebszustand von Bikey an. Der Arduino Mini Pro steuert die drei Grundfarben der LED über die PWM-Outputs 3, 5 und 6. Nach dem Einschalten leuchtet die RGB-LED Blau und signalisiert, dass die Anlage bereit ist und scharfgeschaltet werden kann. Beim erfolgreichen Einlesen des RFID-Tags leuchtet die LED für ein paar Sekunden Grün.

Ein einfacher Piezosummer gibt zeitgleich eine Quittungstonfolge als akustisches Feedback aus. Klappt die Erkennung nicht, leuchtet die RGB-LED Rot und der Pieper gibt eine Warntonfolge aus. Das vermeidet, dass man glaubt, man hätte die Fahrradalarmanlage aktiviert, obwohl es nicht geklappt hat. Beim Deaktivieren oder dem Unterbrechen eines ausgelösten Alarms arbeiten die Anzeige und die akustischen Quittungstöne nach dem gleichen Muster.

Sensoren und Alarmauslösung

Sobald die Anlage scharfgeschaltet ist, wird die Lage des Fahrrads im Raum über einen kombinierten Lage-Beschleunigungssensor ermittelt. Angeschlossen ist der Sensor an den beiden I2C-Bus-Anschlüssen A4 (SDA) und A5 (SCL). Darüber liest der Arduino Mini Pro die Rohdaten der Lage im dreidimensionalen Raum mehrfach aus und bildet Mittelwerte. Diese gemittelten X-, Y- und Z-Koordinaten dienen dann als Referenz. Danach liest der Arduino Mini Pro kontinuierlich die Werte des Lagesensors aus. Macht sich jemand am Fahrrad zu schaffen und verändert die Lage auch nur minimal, dann ändern sich die Werte. Übersteigt einer oder mehrere davon die Referenzwerte deutlich, dann löst der Alarm aus.

Eine 5-V-Sirene gibt ein akustisches Signal mit einem Schallpegel von etwa 110 dB(A) aus. Das ist recht laut und reicht zur Abschreckung aus.

Neben dem Sirenenton signalisiert eine sehr helle 10-mm-Blitz-LED mit ihrem Blinken zusätzlich einen Entwendungsversuchs des Fahrrads. Der Alarm dauert 30 Sekunden. Die Zeit orientiert sich damit an der Alarmdauer herkömmlicher Kfz-Alarmanlagen. Ist der Alarm beendet, bildet der Arduino Mini Pro neue X-, Y- und Z-Referenzwerte. Bewegt ein Dieb das Fahrrad erneut, dann löst der Alarm noch einmal aus. Eine aktive Alarmierung kann ausschließlich mit den registrierten RFID-Tags deaktiviert werden, falls man die Anlage mal versehentlich selbst ausgelöst hat.

Einige Diebe versuchen, Fahrradalarmanlagen vorab mit Kältespray außer Gefecht zu setzen. Der Lage-Beschleunigungssenor enthält ein Temperatur-Modul. Der Arduino Mini Pro misst darüber kontinuierlich die Temperatur. Fällt sie ungewöhnlich schnell ab, dann löst der Alarm ebenfalls aus.

Das Gehäuse und Befestigung am Fahrrad

Eine Fahrradalarmanlage sollte so positioniert sein, dass man sie nicht sofort sieht. Das soll vermeiden, dass ein Dieb sie nicht vorab entfernt oder zerstört. Bei einem Fahrrad ist das kaum möglich. Prinzipiell kommt nur ein Einbau in den Rahmen in Frage. Der Rahmen fällt aber bei vielen Fahrrädern recht schmal aus. Da die Bauteile von Bikey aber etwas größer sind, habe ich darauf verzichtet. Das Verstecken ist ohnehin nicht ganz so wichtig, denn die Alarmanlage löst auch dann aus, wenn jemand versucht, sie zu entfernen.

Ein einfaches Kunststoffgehäuse nimmt die einzelnen Komponenten von Bikey auf, die aus Platzgründen mit Heißkleber fixiert sind. Müssen Teile ausgetauscht werden, kann man sie einfach durch Erwärmen des Heißklebers wieder lösen.

Für die Sirene, die Signal-LED, die Status-LED und den Schalter fräst man entsprechende Aussparungen in das Gehäuse ein. Damit die Sirene nicht so einfach mit einen Schraubenzieher zerstört werden kann, besitzt sie eine Schutzabdeckung, die den Schall nach außen lässt.

Die Befestigung am Fahrrad erfolgt über eine Getränkehalterung für das Sattelrohr. Eine Spezialschraube verhindert, dass ein Dieb den Halter mit Standardwerkzeug abschraubt.

Bauteilliste der Fahrradalarmanlage Bikey

Um Bikey nachzubauen, benötigt man ein paar Bauteile. Die gibt es teuer oder billig. Um den geringen Preispunkt zu erreichen, habe ich mich für die günstige Variante entschieden und viele Teile von einem China-Versand bestellt. Die anderen Bauteile gibt es beim Elektronikhändler des Vertrauens.

• 1 x Arduino Mini Pro (5 V)
• 1 x RFID-Modul RC522 mit RFID-Schlüsselanhänger und RFID-Karte
• 1 x kombinierter Lage- und Bewegungssensor mit Temperatur-Modul GY-521 mit MPU-6050
• 1 x 1-Kanal-Relais-Modul
• 1 x RGB-LED 3 mm
• 1 x Blitz-LED 10 mm
• 4 x Widerstände je nach verwendeten LEDs
• 1 x Piezo-Summer (5 V)
• 1 x Sirene (5 V)
• 1 x Spannungsregler 3,3 V
• 1 x Kondensator 100 nF
• 1 x Kondensator 10 uF
• 1 x Wippschalter (wasser- und staubdicht)
• 1 x Powerbank Amazon Basic 5 V / 2000 mAh
• 2 x Micro-USB-Buchse
• 1 x Gehäuse
• 1 x Halterung für Sattelstütze
• Steckerleisten, Kabel, Schrumpfschlauch

Arduino-Sketch Bikey

Hat man Bikey wie oben beschrieben verdrahtet, dann überträgt man mit der Arduino-Software und einem USB-TTL-Adapter den folgenden Sketch auf den Arduino Mini Pro.

Eventuell reagiert der Lage-Beschleunigungssensor etwas anders, sodass man im Detail kleine Anpassungen am Code bei den Offset-Werten vornehmen muss.

#include "SPI.h"
#include "Wire.h"
#include "MFRC522.h"
#define SS_PIN 10
#define RST_PIN 9

MFRC522 mfrc522(SS_PIN, RST_PIN);

const int MPU_addr=0x68;
const byte schalterbruecke=4;
const byte ledrot=6;
const byte ledgruen=5;
const byte ledblau=3;
const byte ledblitz=7;
const byte signalgeber=2;
const byte sirene=8;
const long maxalarmdauer=30000;
const float offsetmin=0.01;
const float offsetmax=1.99;
byte anhaenger_uid0=0;
byte anhaenger_uid1=0;
byte anhaenger_uid2=0;
byte anhaenger_uid3=0;
byte fehleingabe=0;
int16_t AcX,AcY,AcZ,Tmp,GyX,GyY,GyZ;
unsigned long letzteledblitzmillis=0;
unsigned long ledblitzintervall=300;
unsigned long letztesirenemillis=0;
unsigned long sireneintervall=1500;
float durchschnitt_acx=0;    
float durchschnitt_acy=0;
float durchschnitt_acz=0;
float durchschnitt_tmp=0;
float durchschnitt_gyx=0;
float durchschnitt_gyy=0;
float durchschnitt_gyz=0;
float letzte_temperatur=0;
boolean erster_start=true;
boolean scharf=false;
boolean alarm_verlassen=false;
boolean alarmaktiv=false;
boolean ledblitzzustand=LOW;
boolean sirenezustand=LOW;


void setup()
{
  Serial.begin(9600);
  SPI.begin();
  mfrc522.PCD_Init();
  pinMode(schalterbruecke,OUTPUT);
  pinMode(ledrot,OUTPUT);
  pinMode(ledgruen,OUTPUT);
  pinMode(ledblau,OUTPUT);
  pinMode(ledblitz,OUTPUT);
  pinMode(signalgeber,OUTPUT);
  pinMode(sirene,OUTPUT);
  Wire.begin();
  Wire.beginTransmission(MPU_addr);
  Wire.write(0x6B);
  Wire.write(0);
  Wire.endTransmission(true);
}


void led_schalten(byte rotanteil, byte gruenanteil, byte blauanteil)
{
  analogWrite(ledrot,rotanteil);
  analogWrite(ledgruen,gruenanteil);
  analogWrite(ledblau,blauanteil);
}


void ausgangsbewegungsdaten_setzen()
{
  byte i=0;
  durchschnitt_acx=0;    
  durchschnitt_acy=0;
  durchschnitt_acz=0;
  durchschnitt_tmp=0;
  durchschnitt_gyx=0;
  durchschnitt_gyy=0;
  durchschnitt_gyz=0;
  for (i=0; i<10; i++) 
    {
      Wire.beginTransmission(MPU_addr);
      Wire.write(0x3B);
      Wire.endTransmission(false);
      Wire.requestFrom(MPU_addr,14,true);
      AcX=Wire.read()<<8|Wire.read(); 
      durchschnitt_acx=durchschnitt_acx+AcX;    
      AcY=Wire.read()<<8|Wire.read(); 
      durchschnitt_acy=durchschnitt_acy+AcY;
      AcZ=Wire.read()<<8|Wire.read();  
      durchschnitt_acz=durchschnitt_acz+AcZ;
      Tmp=Wire.read()<<8|Wire.read();  
      durchschnitt_tmp=durchschnitt_tmp+(Tmp/340.00+36.53);
      GyX=Wire.read()<<8|Wire.read();  
      durchschnitt_gyx=durchschnitt_gyx+GyX;
      GyY=Wire.read()<<8|Wire.read(); 
      durchschnitt_gyy=durchschnitt_gyy+GyY;
      GyZ=Wire.read()<<8|Wire.read();
      durchschnitt_gyz=durchschnitt_gyz+GyZ;
      delay(333);
    }
  durchschnitt_acx=durchschnitt_acx/10;
  durchschnitt_acy=durchschnitt_acy/10;
  durchschnitt_acz=durchschnitt_acz/10;
  durchschnitt_tmp=durchschnitt_tmp/10; 
  durchschnitt_gyx=durchschnitt_gyx/10;
  durchschnitt_gyy=durchschnitt_gyy/10;
  durchschnitt_gyz=durchschnitt_gyz/10;
  letzte_temperatur=durchschnitt_tmp;   
}


boolean alarm_notwendig()
{
  boolean accelerationx_ungleich=false;
  boolean accelerationy_ungleich=false;
  boolean accelerationz_ungleich=false;
  boolean gyrox_ungleich=false;
  boolean gyroy_ungleich=false;
  boolean gyroz_ungleich=false;
  boolean temperature_ungleich=false;
  
  Wire.beginTransmission(MPU_addr);
  Wire.write(0x3B);
  Wire.endTransmission(false);
  Wire.requestFrom(MPU_addr,14,true);
  AcX=Wire.read()<<8|Wire.read();   
  AcY=Wire.read()<<8|Wire.read(); 
  AcZ=Wire.read()<<8|Wire.read();
  Tmp=Wire.read()<<8|Wire.read();
  GyX=Wire.read()<<8|Wire.read();  
  GyY=Wire.read()<<8|Wire.read(); 
  GyZ=Wire.read()<<8|Wire.read();
  if (GyX >= 0)
    {
      if ((GyX < (durchschnitt_gyx*offsetmin)) || (GyX > (durchschnitt_gyx*offsetmax)))
        {
          gyrox_ungleich=true;
        }
      else
        {
          gyrox_ungleich=false;
        }
    }
  else
    {
      if ((GyX > (durchschnitt_gyx*offsetmin)) || (GyX < (durchschnitt_gyx*offsetmax)))
        {
          gyrox_ungleich=true;
        }
      else
        {
          gyrox_ungleich=false;
        }        
    }
  if (GyY >= 0)
    {      
      if ((GyY < (durchschnitt_gyy*offsetmin)) || (GyY > (durchschnitt_gyy*offsetmax)))
        {
          gyroy_ungleich=true;
        }
      else
        {
          gyroy_ungleich=false;
        }
    }
  else
    {
      if ((GyY > (durchschnitt_gyy*offsetmin)) || (GyY < (durchschnitt_gyy*offsetmax)))
        {
          gyroy_ungleich=true;
        }
      else
        {
          gyroy_ungleich=false;
        } 
    }
  if (GyZ >= 0)
    {       
      if ((GyZ < (durchschnitt_gyz*offsetmin)) || (GyZ > (durchschnitt_gyz*offsetmax)))
        {
          gyroz_ungleich=true;
        }
      else
        {
          gyroz_ungleich=false;
        }
    }
  else
    {
      if ((GyZ > (durchschnitt_gyz*offsetmin)) || (GyZ < (durchschnitt_gyz*offsetmax)))
        {
          gyroz_ungleich=true;
        }
      else
        {
          gyroz_ungleich=false;
        }  
    }
  if ((Tmp/340.00+36.53) < (letzte_temperatur-3))
    {   
      letzte_temperatur=Tmp/340.00+36.53;
      temperature_ungleich=true;
    }
  else
    {
      letzte_temperatur=Tmp/340.00+36.53;
      temperature_ungleich=false;
    }

  if ((gyrox_ungleich) || (gyroy_ungleich) || (gyroz_ungleich))
    {
      return(true);
    }
  else
    {

      return(false);
    }
}


void loop()
{
  if (erster_start)
    {
      digitalWrite(schalterbruecke,HIGH);
      led_schalten(0,0,255);
      erster_start=false;
    }
  if (!mfrc522.PICC_IsNewCardPresent())
    {
      if (scharf)
        {
          if (alarm_notwendig())
            {
              unsigned long alarmdauer=millis();
              while (((millis()-alarmdauer) < maxalarmdauer) && (!alarm_verlassen))
                {
                  if (mfrc522.PICC_IsNewCardPresent())
                    {
                      if (mfrc522.PICC_ReadCardSerial())
                        {
                          for (byte i=0; i ledblitzintervall) 
                    {
                      letzteledblitzmillis=millis();
                      ledblitzzustand=!ledblitzzustand;
                      digitalWrite(ledblitz,ledblitzzustand);
                    }  
                  if ((millis()-letztesirenemillis) > sireneintervall) 
                    {
                      letztesirenemillis=millis();
                      sirenezustand=!sirenezustand;
                      digitalWrite(sirene,sirenezustand);
                    }
                }
              if (alarm_verlassen)
                {    
                  alarm_verlassen=false;
                  ledblitzzustand=false;
                  digitalWrite(ledblitz,ledblitzzustand);
                  sirenezustand=false;
                  digitalWrite(sirene,sirenezustand);
                  scharf=false;
                  digitalWrite(schalterbruecke,HIGH);
                  led_schalten(0,0,255);
                  digitalWrite(signalgeber,HIGH);
                  delay(300);
                  digitalWrite(signalgeber,LOW);
                  delay(100);
                  digitalWrite(signalgeber,HIGH);
                  delay(300);
                  digitalWrite(signalgeber,LOW); 
                  ausgangsbewegungsdaten_setzen();
                } 
              else
                {
                  alarm_verlassen=false;
                  ledblitzzustand=false;
                  digitalWrite(ledblitz,ledblitzzustand);
                  sirenezustand=false;
                  digitalWrite(sirene,sirenezustand);
                  scharf=true;
                  digitalWrite(schalterbruecke,LOW);
                  led_schalten(0,255,0);
                  digitalWrite(signalgeber,HIGH);
                  delay(300);
                  digitalWrite(signalgeber,LOW);
                  delay(100);
                  digitalWrite(signalgeber,HIGH);
                  delay(300);
                  digitalWrite(signalgeber,LOW); 
                  ausgangsbewegungsdaten_setzen(); 
                  led_schalten(0,0,0);                 
                }
            } 
        }
      return;
    }
  if (!mfrc522.PICC_ReadCardSerial())
    {
      return;
    }
  for (byte i=0; i < mfrc522.uid.size; i++)
    {
      switch(i) 
        {
          case 0: anhaenger_uid0=mfrc522.uid.uidByte[i]; break;
          case 1: anhaenger_uid1=mfrc522.uid.uidByte[i]; break;
          case 2: anhaenger_uid2=mfrc522.uid.uidByte[i]; break;
          case 3: anhaenger_uid3=mfrc522.uid.uidByte[i]; break;
          default: break;
        }
    }
  if (fehleingabe<=5)
    {  
      if (((anhaenger_uid0==164) && (anhaenger_uid1==103) && (anhaenger_uid2==158) && (anhaenger_uid3==187)) || ((anhaenger_uid0==67) && (anhaenger_uid1==144) && (anhaenger_uid2==215) && (anhaenger_uid3==0)))
        {
          fehleingabe=0;
          digitalWrite(signalgeber,HIGH);
          delay(300);
          digitalWrite(signalgeber,LOW);
          delay(100);
          digitalWrite(signalgeber,HIGH);
          delay(300);
          digitalWrite(signalgeber,LOW);    
          if (!scharf)
            {
              scharf=true;
              digitalWrite(schalterbruecke,LOW);
              led_schalten(0,255,0);
              ausgangsbewegungsdaten_setzen();
            }
          else
            {
              scharf=false;
              digitalWrite(schalterbruecke,HIGH);
              led_schalten(0,0,255);
              delay(3000);
            }
          led_schalten(0,0,0);
        }
      else
        {
          fehleingabe++;
          led_schalten(255,0,0);
          digitalWrite(signalgeber,HIGH);
          delay(1000);
          digitalWrite(signalgeber,LOW); 
          delay(3000);
          led_schalten(255,0,0);
        }
    } 
  else   
    {
      fehleingabe=0;
      led_schalten(255,0,0);
      digitalWrite(signalgeber,HIGH);
      delay(1000);
      digitalWrite(signalgeber,LOW);
      delay(1000);
      digitalWrite(signalgeber,HIGH);
      delay(1000);
      digitalWrite(signalgeber,LOW); 
      delay(15000);
      led_schalten(255,0,0);
    }
}

Fazit

Bikey ist in wenigen Stunden aufgebaut. Die Elektronik ist schnell verdrahtet, das Gehäuse ohne großen Aufwand mit Löchern versehen und der Arduino-Sketch flott programmiert.

Wer Bikey nachbauen und Verbesserungsvorschläge zum Sketch machen möchte, der kann das gerne per Kommentar unter dem Artikel tun. Vielleicht wird die Fahrradalarmanlage dann noch etwas sicherer. Das Gewissen beruhigt sie aber jetzt auch schon ganz gut.