Dein VB.NET Programm automatisch bei Systemstart starten

Hast Du Deine nächste tolle Anwendung entwickelt, Welche Du nun via VB.NET in den Autostart packen möchtest? Im heutigen Beitrag schauen wir uns genau das und mehr, wie z. B. das Erstellen von Verknüpfungen via der „WshShell“ an. Bleib also dran, es wird ziemlich interessant 😉!

💡 Hinweis: Wenn Du es eilig hast, kannst Du auch direkt zum Code weiter unten scrollen, bzw. das Inhaltsverzeichnis für das Springen zu verschiedenen Eckpunkten verwenden. Auch wenn der Beitrag seinen Fokus auf VB.NET hat, sind alle Code-Beispiele natürlich auch für C# verfügbar! Springe für den kompletten Code, oder für dessen Verwendungsbeispiele nach unten.

Wie Du vielleicht weißt hatte ich auch schonmal ein Video zum Thema gemacht – vor unfassbaren 11 Jahren, oh man, ich werde alt.. Ein Abonnent hatte mich darauf aufmerksam gemacht, dass es in die Jahre gekommen ist und er sich ein Update wünscht. Dies war mir Befehl und nun sind wir hier 🤓!

Wenn Du moderne Anwendungen entwickeln möchtest – Welche dann passenderweise in den Autostart können –, solltest Du Dir unbedingt diese beiden Beiträge anschauen:

• Der ultimative INotifyPropertyChanged Guide – für C# & VB.NET
• Der ultimative WPF DataGrid MVVM Guide – C# & VB.NET

Als Video ansehen – „VB.NET Autostart von Programmen“

Wenn Du es eiliger, bzw. eventuell keine Lust auf Text hast, kannst Du natürlich auch gerne zum Videoformat greifen und Dich berieseln lassen. Nutze auch im Video gerne die Kapitel, um zu den Stellen von besonderem Interesse zu springen.

Wie startet man Software überhaupt via Autostart?

Bevor wir uns an die VB.NET-spezifische Thematik wagen, ist es ggf. vorerst ganz sinnvoll, sich mit dieser Frage auseinanderzusetzen: Wie starte ich ein Programm überhaupt bei Systemstart? Grundsätzlich ist die Antwort darauf ziemlich einfach, denn Windows bietet eigentlich alle Bordmittel, Die man als Administrator oder auch Entwickler, braucht.

Dazu gibt es den sogenannten Autostart-Ordner, Welcher ungefähr so wie gleich folgend aussieht. Bei mir ist – zugegebenermaßen – nicht viel dort zu sehen, denn ich versuche den immer „clean“ zu halten.

Vorgehensweise

Um ein Programm beim Start des Windows-Systems automatisch mit-starten zu lassen, muss man Dieses, bzw. eine Verknüpfung dazu in den Autostart-Ordner ablegen. Das Schöne ist hier wirklich die Möglichkeit der Verknüpfung, denn wer hat Lust, jedes Mal x Megabyte zu kopieren und eventuell dann doppelt zu haben. Ich persönlich hatte bei dieser Vorgehensweise auch nie Probleme, im Gegensatz zu einigen recherchierten Suchergebnissen auf Google. Kommentiere gerne, wenn auch Du auf derartige Probleme stößt, würde mich interessieren!

Vorsicht geboten

Wie erwähnt wird jedes Programm, bzw. jede Verknüpfung im genannten Ordner automatisch bei Systemstart gestartet. Das stattet uns Entwickler & Administratoren natürlich auch mit einer großen Bürde aus. Erstens – so finde ich – sollte man dem Nutzer bei Systemstart nicht direkt 20 GUIs an den Kopf schmeißen und zweitens sollte man ja auch noch an die Startzeit denken. Wer hat schon Lust, 5 Minuten länger zu warten, nur weil ein Programm bei Start schon viel Auslastung zieht!?

Welche Möglichkeiten habe ich beim Autostart?

Egal ob mit VB.NET (oder C#..), oder ohne, wir haben verschiedene Möglichkeiten, den Autostart zu verwenden. Einerseits können wir benutzerspezifische Startmöglichkeiten verwenden, oder auch global, also für alle Nutzer einen automatischen Programmstart anlegen. In diesem Beitrag gehe ich jedoch in erster Linie auf den benutzerspezifischen Autostart ein.

Wo, bzw. wie finde ich die Autostart-Ordner?

In erster Linie kommt das natürlich darauf an, für wen Du einen Autostart erstellen möchtest. Möchtest Du Dein Programm z. B. für den aktuellen Nutzer in den Autostart legen, dann kommt folgendes Verzeichnis in Frage. Beachte hierbei, dass Du den Platzhalter natürlich durch den jeweiligen Nutzernamen ersetzen müsstest:

C:\Users\<DeinNutzername>\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup

Du kannst den Ordner auch vereinfacht finden, indem Du die Windows-Taste+R drückst, was den „Ausführen“-Dialog startet. Und im nächsten Schritt dann:

shell:startup

eingeben, was Dich dann in dem für Dich passenden Autostart-Ordner auskommen lässt. Cool, oder?

Globaler Autostart-Ordner

Möchtest Du hingegen den „globalen“ Ordner finden, kannst Du stattdessen in folgendem Verzeichnis

C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp

und mit diesem Befehl hier fündig werden (denke an Windows-Taste+R):

shell:common startup

Hier findest Du dann die Programme, Welche für alle Nutzer automatisch bei Systemstart gestartet werden sollen.

Wie sieht der VB.NET Autostart nun aus?

Um nun die oben erklärte Logik, bzw. Vorgehensweise mit VB.NET nachzubilden, müssen wir ja praktisch nichts Anderes tun. Wir müssen (via Code) eine Verknüpfung unserer Anwendung erschaffen und Diese nach Möglichkeit im Autostart-Ordner unserer Wahl unterbringen. Besonders die Erstellung einer Verknüpfung kann aber tricky sein, wenn man nicht weiß, wie.

Zusätzlich könnte man weitere Hilfsmittel schreiben, um z. B. überprüfen zu können, ob sich unsere Anwendung aktuell schon im Autostart befindet. Dies alles werden wir selbstverständlich nach Regeln der OOP (Objektorientierten Programmierung) in eine Klasse auslagern. So bleibt alles schön wiederverwendbar und portierbar.

Lege also im nächsten Schritt einen Ordner namens „Utils“ in Deinem Projekt an und erstelle dort drin eine „Autostart“-Klasse.

Mit VB.NET den Autostart-Ordner ermitteln

Bevor wir uns jedoch Gedanken über Dinge wie „Wie kann ich die Verknüpfung erstellen“, usw. machen, starten wir easy. Zuerst einmal müssen wir wissen, wie wir an den Autostart-Ordner kommen, ist ja schließlich Betriebssystem-Sache. Zufälligerweise benutzen wir eine optimale Sprache für dieses Betriebssystem vom selben Hersteller – kann ja dann nicht so schwer sein, richtig? Richtig!

Um an den Pfad zum Autostart-Ordner (auch Startup-Folder genannt) zu kommen, können wir vorgefertigte Funktionen nutzen. Die Methode unseres Vertrauens befindet sich in der „Environment“-Klasse und heißt „GetFolderPath“. Diese erwartet einen Wert der „SpecialFolder“-Enumeration aus selbiger Klasse.

Implementieren wir nun eine Art „Singleton“-, bzw. eine „Lazy“-Property (Eigenschaft), Welche uns den Autostart-Ordner serviert. So müssen wir der Environment nicht öfter als nötig auf die Nerven gehen – ergo, die Funktion nur einmalig aufrufen und den Rückgabewert zwischenspeichern:

        Private Shared _startupDirectory As String

        Public Shared ReadOnly Property StartupDirectory As String
            Get
                If String.IsNullOrWhiteSpace(_startupDirectory) Then
                    _startupDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Startup)
                End If
                Return _startupDirectory
            End Get
        End Property

    private static string _startupDirectory;

    public static string StartupDirectory
    {
        get
        {
            if (string.IsNullOrWhiteSpace(_startupDirectory))
                _startupDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Startup);
            return _startupDirectory;
        }
    }

Einen Eintrag in den Autostart mit VB.NET hinzufügen

Im nächsten Schritt schauen wir uns an, wie wir unsere VB.NET-Anwendung, bzw. eine Verknüpfung davon in den Autostart-Ordner gelegt bekommen. Dazu bauen wir uns eine kleine „AddEntry“ Methode, Welcher es egal ist, ob ein Pfad zu unserer Anwendung mitkommt, denn Diesen, kann Sie auch selbst ermitteln. So bleibt uns die Möglichkeit übrig, fremde Anwendungen, sowie die Eigene gemütlich hinzuzufügen:

        ''' <summary>
        ''' Adds an entry to the autostart folder for the given Application
        ''' </summary>
        ''' <param name="applicationFilePath">The given application filepath, or empty to create an autostart for the current executing .exe</param>
        Public Shared Sub AddEntry(Optional applicationFilePath As String = "")
            Dim noAppPathProvided = applicationFilePath = ""
            If noAppPathProvided Then
                DefaultToExecutingExe(applicationFilePath)
            End If
            CreateShortcut(applicationFilePath)
        End Sub

/// <summary>
/// Adds an entry to the autostart folder for the given Application
/// </summary>
/// <param name="applicationFilePath">The given application filepath, or empty to create an autostart for the currently executing .exe</param>
public static void AddEntry(string applicationFilePath = "")
{
    var noAppPathProvided = applicationFilePath == "";
    if (noAppPathProvided)
        DefaultToExecutingExe(applicationFilePath);
    CreateShortcut(applicationFilePath);
}

Wie Du hier schon sehen kannst, schauen wir (wie erwähnt), ob ein passender „applicationFilePath“ mitgeliefert wurde. Wenn nicht „Defaulten“ wir zur ausführenden Exe-Datei, also dem aktuellen Programm. So oder so erstellen wir am Ende der Methode eine Verknüpfung, was wir im nächsten Schritt besprechen werden.

Die ausgeführte .Exe-Datei erkennen

Nachdem wir die eigentliche Methode schon einmal im letzten Schritt vorbereitet haben, fehlen nun noch die 2 Sub-Routinen. In erster Linie schauen wir hier uns hier schnell die „DefaultToExecutingExe“-Methode an. Diese bekommt einen „ByRef“-Parameter übergeben – empfand ich hier irgendwie leichter lesbar – aber ist nur meine Meinung. Diese setzt dann den „applicationFilePath“ via „Process“-Klasse, bzw. mittels einer verschachtelten Sub-Eigenschaft des Prozesses. Diesen ermitteln wir mit der statischen „GetCurrentProcess“-Funktion der „Process“-Klasse. Hier gibt es ab .NET 6 auch eine neue Variante, allerdings habe ich hier Die genommen, Welche vermutlich am geläufigsten ist.

Unsere VB.NET Anwendung als Verknüpfung in den Autostart legen

Nun fehlt nur noch ein letztes Werkzeug, die Funktionalität, für unsere (und auch andere Anwendungen) eine Verknüpfung erzeugen zu können. Dies kann – wie oben bereits erwähnt – ein wenig tricky werden, wenn man nicht weiß, wie. Wir verwenden dazu das „WshShell“-Interface, Welches komischerweise instanziiert werden kann, Du glaubst mir nicht? Guck in den Code!

COM-Verweis hinzufügen

Bevor wir damit jedoch starten können, müssen wir zuerst noch den benötigten COM-Verweis auf das „Windows Script Host Object Model“ hinzufügen. Das kannst Du ganz einfach machen, indem Du einen Rechtsklick auf Dein Projekt durchführst und anschließend „Hinzufügen->COM-Verweis“ auswählst.

Danach erscheint dieses folgende Fenster, wo Du dann oben rechts dementsprechend z. B. nach „host“ suchen kannst, dann dürftest Du – siehe Bild – schnell fündig werden:

Ein instanziierbares Interface – what the f**?

Um ehrlich zu sein – wie ich nunmal bin.. – habe ich mich selbst damit auch nicht auseinandergesetzt, warum man diese Schnittstelle instanziieren kann (auch in C#). Und da ich COM-Dinge eigentlich nie benötige, ist mir das hier auch relativ egal, solange es funktioniert. Ich gehe mal ohne Recherche davon aus, dass das an der Deklaration des Interfaces liegt, dort sehen wir ein „CoClass“-Attribut.

Vermutlich wird „der Code“ dann sehen: „Ah, da ist ein CoClass Ding, also muss ich das wohl instaziieren“ – oder so ähnlich. EDIT: Habe kurz nachgeguckt, liegt wie vermutet an dem „CoClass“-Attribut – Erfahrung „strikes again“ 😉!

Eine Verknüpfung erstellen

Nachdem wir das Interface nun instanziieren können – ew, klingt immer noch ekelig, na egal – tun wir gleich genau das. Vorher erstellen wir noch ein „FileInfo“-Objekt, Welches uns bei der Arbeit mit Datei-Infos wie den Namen der Datei, usw. unterstützen wird. Und dann gehen wir schonmal hin und erstellen den letztendlichen Pfad der Verknüpfung mit String-Interpolation.

Hier verwenden wir ein weiteres kleines Helferlein, was – wie der Name schon sagt – den Dateinamen ohne Dateiendung für uns herausfiltert. Dazu übergeben wir der statischen „Path“-Klassen-Funktion „GetFileNameWithoutExtension“, den Namen des „FileInfo“-Objektes.

Im letzten Schritt erzeugen wir die Verknüpfung auf Objekt-Ebene und casten Sie in ein für unsere Zwecke passendes Interface – „IWshShortcut“. Anschließend kannst Du weitere Eigenschaften wie z. B. die Beschreibung und den Icon-Pfad angeben, dies lasse ich hier aber aus. Zuletzt kommen die beiden wichtigsten Schritte: Den Ziel-Pfad, also den Pfad zur eigentlichen Anwendung festzulegen und dann final auch „Save“ aufzurufen, damit die Verknüpfung tatsächlich erstellt wird.

Prüfen ob ein Autostart-Eintrag existiert

Nun haben wir die Funktionalität von oben vorliegen und würden direkt mit der Nächsten starten. Es wäre schließlich ganz nützlich, wenn man auch prüfen könnte, ob bereits eine Verknüpfung im Autostart ist. Dazu erstellen wir im nächsten Schritt eine „EntryExists“-Funktion, Welche dies über einen Boolean kommuniziert.

In den ersten Zeilen verfahren wir hier wir in der „AddEntry“-Methode, also bezogen auf die Pfad-Sache. Wenn kein Pfad angegeben wurde, nehmen wir den Pfad der aktuellen Exe-Datei, usw. Danach bauen wir uns den Pfad zur Verknüpfung (im Autostart-Ordner!) zusammen. Wenn eine derartige Datei (dort) existiert, dann haben wir das Programm bereits im Autostart – yay!

        Public Shared Function EntryExists(Optional applicationFilePath As String = "") As Boolean
            Dim noAppPathProvided = applicationFilePath = ""
            If noAppPathProvided Then
                DefaultToExecutingExe(applicationFilePath)
            End If
            Dim applicationFile = New FileInfo(applicationFilePath)
            Dim shortcutPath = Path.Combine(StartupDirectory, $"{Path.GetFileNameWithoutExtension(applicationFile.Name)}.lnk")
            Return IO.File.Exists(shortcutPath)
        End Function

public static bool EntryExists(string applicationFilePath = "")
{
    var noAppPathProvided = applicationFilePath == "";
    if (noAppPathProvided)
        DefaultToExecutingExe(applicationFilePath);
    var applicationFile = new FileInfo(applicationFilePath);
    var shortcutPath = Path.Combine(StartupDirectory, $"{Path.GetFileNameWithoutExtension(applicationFile.Name)}.lnk");
    return System.IO.File.Exists(shortcutPath);
}

Mit VB.NET den Autostart wieder entfernen

Im letzten Abschnitt dieses Beitrages werden wir uns ansehen, wie wir erzeugte Einträge auch wieder entfernen können. Dies kennt man natürlich bereits aus größeren Tools. Wir schreiben also eine „RemoveEntry“-Methode, Welche sehr ähnlich zu den Vorherigen funktioniert. Zuerst prüfen wir wieder die Pfad-Übergabe, danach erstellen wir der Einfachheit halber eine „FileInfo“ und danach generieren wir den Verknüpfungs-Pfad.

Wenn Dieser Pfad existent ist, wird er gelöscht, somit wird auch unser VB.NET Autostart entfernt. Beachte hierbei, dass ich bewusst kein Try-Catch drum gemacht habe. Ich möchte aktiv auf Fehler reagieren und diese separat und sauber verarbeiten können.

Kompletter Code

Hier findest Du den wichtigsten Code für diesen Beitrag. In diesem Beispiel handelt es sich um die kleine von mir gebaute Hilfs-Klasse. Diese vereinfacht Dir die Erstellung der Programm-Verknüpfung innerhalb des Autostart-Ordners via VB.NET (und C#!):

Imports System.IO
Imports IWshRuntimeLibrary

Namespace Utils

    Public Class Autostart

        Private Shared _startupDirectory As String

        Public Shared ReadOnly Property StartupDirectory As String
            Get
                If String.IsNullOrWhiteSpace(_startupDirectory) Then
                    _startupDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Startup)
                End If
                Return _startupDirectory
            End Get
        End Property

        ''' <summary>
        ''' Adds an entry to the autostart folder for the given Application
        ''' </summary>
        ''' <param name="applicationFilePath">The given application filepath, or empty to create an autostart for the current executing .exe</param>
        Public Shared Sub AddEntry(Optional applicationFilePath As String = "")
            Dim noAppPathProvided = applicationFilePath = ""
            If noAppPathProvided Then
                DefaultToExecutingExe(applicationFilePath)
            End If
            CreateShortcut(applicationFilePath)
        End Sub

        Private Shared Sub DefaultToExecutingExe(ByRef applicationFilePath As String)
            applicationFilePath = Process.GetCurrentProcess().MainModule.FileName
        End Sub

        Private Shared Sub CreateShortcut(applicationFilePath As String)
            Dim applicationFile = New FileInfo(applicationFilePath)
            Dim shortcutPath = Path.Combine(StartupDirectory, $"{Path.GetFileNameWithoutExtension(applicationFile.Name)}.lnk")
            Dim shell = New WshShell()
            Dim shortcut = CType(shell.CreateShortcut(shortcutPath), IWshShortcut)
            With shortcut
                ' .Description = ""
                ' .IconLocation = ""
                .TargetPath = applicationFile.FullName
                .Save()
            End With
        End Sub

        Public Shared Function EntryExists(Optional applicationFilePath As String = "") As Boolean
            Dim noAppPathProvided = applicationFilePath = ""
            If noAppPathProvided Then
                DefaultToExecutingExe(applicationFilePath)
            End If
            Dim applicationFile = New FileInfo(applicationFilePath)
            Dim shortcutPath = Path.Combine(StartupDirectory, $"{Path.GetFileNameWithoutExtension(applicationFile.Name)}.lnk")
            Return IO.File.Exists(shortcutPath)
        End Function

        Public Shared Sub RemoveEntry(Optional applicationFilePath As String = "")
            Dim noAppPathProvided = applicationFilePath = ""
            If noAppPathProvided Then
                DefaultToExecutingExe(applicationFilePath)
            End If
            Dim applicationFile = New FileInfo(applicationFilePath)
            Dim shortcutPath = Path.Combine(StartupDirectory, $"{Path.GetFileNameWithoutExtension(applicationFile.Name)}.lnk")
            IO.File.Delete(shortcutPath)
        End Sub

    End Class

End Namespace

using System.IO;
using IWshRuntimeLibrary;

namespace Utils
{
    public class Autostart
    {
        private static string _startupDirectory;

        public static string StartupDirectory
        {
            get
            {
                if (string.IsNullOrWhiteSpace(_startupDirectory))
                    _startupDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Startup);
                return _startupDirectory;
            }
        }

        /// <summary>
        ///         ''' Adds an entry to the autostart folder for the given Application
        ///         ''' </summary>
        ///         ''' <param name="applicationFilePath">The given application filepath, or empty to create an autostart for the current executing .exe</param>
        public static void AddEntry(string applicationFilePath = "")
        {
            var noAppPathProvided = applicationFilePath == "";
            if (noAppPathProvided)
                DefaultToExecutingExe(ref applicationFilePath);
            CreateShortcut(applicationFilePath);
        }

        private static void DefaultToExecutingExe(ref string applicationFilePath)
        {
            applicationFilePath = Process.GetCurrentProcess().MainModule.FileName;
        }

        private static void CreateShortcut(string applicationFilePath)
        {
            var applicationFile = new FileInfo(applicationFilePath);
            var shortcutPath = Path.Combine(StartupDirectory, $"{Path.GetFileNameWithoutExtension(applicationFile.Name)}.lnk");
            var shell = new WshShell();
            var shortcut = (IWshShortcut)shell.CreateShortcut(shortcutPath);
            {
                var withBlock = shortcut;
                // .Description = ""
                // .IconLocation = ""
                withBlock.TargetPath = applicationFile.FullName;
                withBlock.Save();
            }
        }

        public static bool EntryExists(string applicationFilePath = "")
        {
            var noAppPathProvided = applicationFilePath == "";
            if (noAppPathProvided)
                DefaultToExecutingExe(ref applicationFilePath);
            var applicationFile = new FileInfo(applicationFilePath);
            var shortcutPath = Path.Combine(StartupDirectory, $"{Path.GetFileNameWithoutExtension(applicationFile.Name)}.lnk");
            return System.IO.File.Exists(shortcutPath);
        }

        public static void RemoveEntry(string applicationFilePath = "")
        {
            var noAppPathProvided = applicationFilePath == "";
            if (noAppPathProvided)
                DefaultToExecutingExe(ref applicationFilePath);
            var applicationFile = new FileInfo(applicationFilePath);
            var shortcutPath = Path.Combine(StartupDirectory, $"{Path.GetFileNameWithoutExtension(applicationFile.Name)}.lnk");
            System.IO.File.Delete(shortcutPath);
        }
    }
}

Verwendung des Codes

Um den obigen Code verwenden zu können, kannst Du z. B. 2 Knöpfe und eine CheckBox in Deine Form setzen. Beim Start des Formulares wird die Checkbox je nachdem ob das VB.NET Programm im Autostart liegt gefüllt. Wenn Du dann auf die jeweiligen Buttons drückst, kannst Du das Programm wieder aus dem Autostart entfernen, bzw. natürlich auch hinzufügen. Die Namen sind denke ich selbsterklärend..

Imports AutoStartExampleVb.Utils

Public Class Form1

    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        chbAutostartActivated.Checked = Autostart.EntryExists()
    End Sub

    Private Sub btnActivateAutostart_Click(sender As Object, e As EventArgs) Handles btnActivateAutostart.Click
        Autostart.AddEntry()
        chbAutostartActivated.Checked = True
    End Sub

    Private Sub btnDeactivateAutostart_Click(sender As Object, e As EventArgs) Handles btnDeactivateAutostart.Click
        Autostart.RemoveEntry()
        chbAutostartActivated.Checked = False
    End Sub

End Class

using System;
using AutoStartExampleVb.Utils;

public class Form1
{
    private void Form1_Load(object sender, EventArgs e)
    {
        chbAutostartActivated.Checked = Autostart.EntryExists();
    }

    private void btnActivateAutostart_Click(object sender, EventArgs e)
    {
        Autostart.AddEntry();
        chbAutostartActivated.Checked = true;
    }

    private void btnDeactivateAutostart_Click(object sender, EventArgs e)
    {
        Autostart.RemoveEntry();
        chbAutostartActivated.Checked = false;
    }
}

Downloads

Keine Lust alles zu kopieren und es manuell zusammen zu frickeln? Dann lade Dir hier einfach den Beispielcode herunter, Dieser beinhaltet die komplette und fertig testbare Projektmappe.

Der Beitrag VB.NET Autostart für Dein eigenes Programm erstellen – 2024 Version erschien zuerst auf Robert Skibbe.

Eigener Arduino RFID Scanner

Im heutigen Beitrag erstellen wir einen eigenen Arduino RFID Scanner, Welcher die UIDs der gängigen Chipkarten / Tags auslesen kann. Damit können wir die jeweiligen Tags identifizieren und verschiedene Dinge, wie z. B. Zugriffskontrollen realisieren. Im einem der letzten Beiträge haben wir uns schon die Verarbeitung seitens einer .NET Programmiersprache wie C# / VB.NET angesehen.

Dort lag der Fokus eher auf der Verarbeitung der Signale, bzw. Daten der fertigen Hardware. Wir hatten die Lötarbeiten inkl. der Mikrocontroller-Software also schon mehr oder weniger vorausgesetzt. Heute werden wir die andere Seite beleuchten, also die Programmierung der passenden Software seitens unseres Arduino Mikrocontrollers.

Obwohl ich selbst jetzt nicht gerade der Profi-Elektroniker (sondern Entwickler 😛) bin, bekommen wir das mit den Lötarbeiten am Arduino RFID Scanner schon hin. Zum Glück handelt es sich hierbei auch um eine ziemliche einfache Verbindung, wo wir nicht großartig rätseln müssen – 💪!

💡 Bei den einzelnen Produkt-Links handelt es sich ggf. um sogenannte Affiliate-Links. Wenn Du einen Artikel über einen jeweiligen Link erwirbst, bedankst Du Dich völlig ohne extra Kosten bei mir, indem ich einen geringen Anteil des Kaufbetrages bekomme. Falls Du das nicht möchtest, kannst Du die Artikel natürlich auch ohne meine Links suchen und kaufen.

Benötigtes Zubehör

Schauen wir uns zuerst einmal an, Welches hardwaremäßige Zubehör für die Umsetzung unseres RFID Scanners benötigen. Auch wenn der Code natürlich auch erstmal so auf einem Arduino Nano, etc. laufen sollte, wird die Scan-Funktionalität natürlich nur mit dem passenden RFID-Modul funktionieren. Hier eine kleine Liste der benötigten Dinge.

	Arduino Nano
	RFID Kit
	Jumper Kabel

Arduino Nano – der Mikrocontroller

Als erstes Teil benötigst Du die Kernkomponente des Ganzen: Den Mikrocontroller. Ich persönlich habe mir damals ein Multi-Pack gekauft, da ich es als blödsinnig empfand, für einen einzigen Arduino Lieferkosten zu zahlen. Daher habe ich auch hier direkt das 3er Paket verlinkt. Achte bei Deinem Kauf darauf, dass passende USB-Kabel dabei sind!

RFID Kit

Der nächste Punkt auf unserer Shopping-Liste wäre das typische RFID-Kit. Hier ist alles dabei was wir brauchen. Einerseits haben wir verschiedene scanbare Tags und das Wichtigste: Unser Arduino RFID Modul.

Jumper Kabel

Im letzten Schritt müssen wir alles natürlich auch gut miteinander verbinden können. Dazu habe ich einen Mix aus verschiedenen Jumper-Kabeln ausgesucht. In unserem Beispiel (je nachdem was Du sonst da hast, oder gekauft hast) benötigen wir eigentlich nur „Female to Female“ Kabel. Beachte hierzu auch noch den Hinweis unten drunter!

⚠️ Achte beim Kauf darauf, ob Du gewillt bist, selbst zu löten. Falls Du nicht selbst löten möchtest, kannst Du am besten schon fertig verlötete Geräte kaufen. Meistens geben die Verkäufer diese Info im Verkaufsangebot an. Frag im Zweifelsfall nach!

Löt- & Verbindungsarbeiten am Arduino RFID Scanner

Um Deinen Arduino RFID Scanner soweit für die aktive Arbeit an der Software vorzubereiten, müssen wir Diesen nun im nächsten Schritt erstmal herrichten. Genauer genommen geht es jetzt an die kleinen Lötarbeiten, Welche zu verrichten wären. Ich werde Dir einmal ein Bild von der fertigen Hardware präsentieren und andererseits mit Text auf die Sprünge helfen.

Die Verbindung – tabellarische Übersicht

Hier findest Du einen tabellarischen Überblick über die Verbindung mit dem RFID-Kit RC522. Einerseits haben wir die typisch notwendigen Dinge wie den Stromkreislauf (GND = Ground = Masse, Spannung 3,3V), andererseits Signale auf den digitalen Pins, sowie einen ausgelassenen Anschluss.

Die fertige Hardware – als Bild

Hier siehst Du die oben beschriebenen Verbindungen als fertiges Bild, leider nicht annähernd so toll, wie ein visueller Schaltplan, aber „It’s something“… Im Endeffekt soll’s nur einmal zeigen, wie es fertig aussieht, die Pinbelegungen sind hier leider weniger zu erkennen – sorry dafür.

Die Hardware mit dem PC verbinden

Im nächsten Schritt werde ich ein wenig darauf eingehen, wie Du Deinen nun fertigen Arduino RFID Scanner mit Deinem PC verbinden kannst. Wenn Du das bereits geschafft hast, Glückwunsch – Du kannst Diesen Teil hier überspringen. Falls nicht, fahren wir zuerst mit dem Download des Treibers für den CH340 Chip fort.

Besuche also als nächstes die Homepage für den Treiber, Welche leider in chinesisch ist. Verwende falls nötig / falls hilfreich z. B. die Übersetzungs-Funktion eines jeden modernen Browsers. Falls Du eine detailliertere Anleitung benötigst, kannst Du auch zum anderen Teil dieses zweiteiligen Beitrages gehen.

Kurzum würde ich sagen, installiere den Treiber, starte Deinen PC am besten einmal neu und schon bist Du für die Verbindung über Mini-USB ready. Falls Du nicht weiter kommst, gehe wie gesagt einmal zum anderen Teil und schaue Dir dort die bessere Anleitung hierzu an. Ich wollte es nur ungern wiederholen..

Wenn alles geklappt hat, solltest Du den angeschlossenen Arduino nun als verbundenen COM-Port sehen. Ein Beispiel findest Du hier in meinem Bild, dort ist der Arduino am Port „COM3“ angeschlossen:

Arduino RFID Code

Kommen wir nun zum – für mich – interessantesten Teil: Der Code für unseren RFID Scanner aus der Arduino IDE! Zuerst fehlt noch eine Kleinigkeit, denn wir möchten den Code, der für die Kommunikation mit dem Gerät notwendig ist, mit Sicherheit nicht komplett von vorn, bzw. in Eigenarbeit schreiben.

Daher müssen wir nun zuerst einmal die Library / Bibliothek einbinden, Welche dafür notwendig ist und bereits fertig angeboten wird. Um es Dir so einfach wie möglich zu machen, habe ich Dir meine verwendete Version / Variante unten bei den Downloads hinzugefügt. Lade Dir die Datei herunter und im nächsten Schritt binden wir Diese auch sofort in unsere Arduino IDE ein.

Library zur RFID Kommunikation einbinden

Begebe Dich nach dem Download der unter Downloads gelisteten Library nun in die Arduino IDE. Dort klickst Du auf „Sketch->Bibliothek einbinden->.Zip-Bibliothek hinzufügen“. Dann zeigst Du dem Ding einfach die heruntergeladene Zip-Datei und fertig.

Der Code selbst

Nun fangen wir endlich mit unserem eigenen Code an, öffne dazu ein neues Arduino Projekt und speichere es z. B. als „RFID Beispiel“ ab. Alternativ kannst Du natürlich in/mit der anderen unter Downloads angebotenen Projektdatei rumspielen.

Nachdem die Datei vorhanden ist und wir mit eigenem Code spielen können, binden wir zuerst einmal die notwendigen Bibliotheken ein. Die erste einzubindende Bibliothek ist die „SPI.h“-Datei, dann noch die „MFRC522.h“.

Wundere Dich nicht, wir haben die „SPI“-Bibliothek nicht heruntergeladen – brauchen wir auch nicht. Dabei handelt es sich um eine Standard-Bibliothek, Welche wir durch die Arduino IDE mitgeliefert bekommen.

Imports usw

#include <SPI.h>
#include <MFRC522.h>

Nach den Imports/Includes definieren wir nun 2 Konstanten für den SDA und den Reset Pin. Danach erstellen wir eine neue MFRC522-Instanz mit diesen beiden Konstanten als Parameter.

#define SS_PIN 10
#define RST_PIN 9
MFRC522 mfrc522(SS_PIN, RST_PIN);

Setup-Funktion

Nun versehen wir die Setup-Funktion des Arduino Codes mit Inhalt. Nicht vergessen, diese wird einmalig bei Start/Stromversorgung des Arduinos aufgerufen. In der ersten Zeile starten wir eine serielle Kommunikation mit der Baudrate von 9600. Danach sagen wir auch der SPI Lib „go“, Welche auch ihren Anteil dazu beiträgt. Zuletzt initialisieren wir den MFRC522 Chip, um damit zu interagieren.

void setup() {
  Serial.begin(9600);
  SPI.begin();
  mfrc522.PCD_Init();
}

Haupt-Loop

Im nächsten Schritt kommt die Haupt-Funktion des Arduino-Codes – die Haupt-Schleife. Dies ist der in einer Endlosschleife laufende Code, Welcher unsere Chips letztendlich verarbeitet. Die erste (If-) Anweisung prüft, ob eine neue Karte vorhanden ist. Danach wählen wir (laut Recherche der Funktion) die Karte aus. Verbessere mich hier gerne in den Kommentaren, falls Du es genauer weißt!

void loop() {
  if (!mfrc522.PICC_IsNewCardPresent())
    return;

  if (!mfrc522.PICC_ReadCardSerial())
    return;

  // more...
}

GetId-Funktion – Kleine Hilfe

Als nächstes definieren wir uns eine Hilfs-Funktion, um die jeweilige Card-Id auszulesen. Diese geht in einer zähler- und kopfgesteuerten Schleife (for) die einzelnen Uid-Bytes durch (die Bytes der ID – anhand des „size“ Wertes). Dabei setzen wir die ID aus der hex-repräsentativen Form zusammen. Solange wir nicht im letzten Block der UID-Blöcke angekommen sind, erweitern wir den String um ein Leerzeichen (sieht man gleich im Screenshot).

Zum Schluss wandeln wir dann alles noch in Großbuchstaben (wie für Hex-Werte üblich) um und geben es durch „return“ wieder.

String getCardId() {
  String uid = "";
  for (byte i = 0; i < mfrc522.uid.size; i++)
  {
    uid.concat(String(mfrc522.uid.uidByte[i], HEX));
    if (i < mfrc522.uid.size - 1)
      uid.concat(" ");
  }
  uid.toUpperCase();
  return uid;
}

Zuletzt müssen wir die Funktion dementsprechend dann nur noch aufrufen und die bekommene ID verarbeiten. Mit der PICC_HaltA() Methode stoppen wir dann noch den Lesevorgang und verzögern das ganze Programm ein wenig – lasse die Verzögerung für Testzwecke gerne einmal weg.

  String uid = getCardId();
  // Serial.println("RFID:" + uid);
  // do something with uid!
  mfrc522.PICC_HaltA();
  delay(1000);

Hier habe ich beispielhaft mal 2 dieser typischen blauen Schlüsselanhänger-Chips und eine Chipkarte ausgelesen:

Dabei kamen dann die folgenden Werte heraus (nicht vergessen es bei Bedarf auszugeben, also mit Serial.println.. – ist oben auskommentiert). Strg+Shift+M öffnet den seriellen Monitor, um die Ausgabe des Arduinos zu beobachten. Hierbei muss man auch auf die korrekte Baudrate – in diesem Fall 9600 – achten.

Kompletter Code

Hier zeige ich am Ende nochmal den kompletten Arduino RFID Scanner Code:

#include <SPI.h>
#include <MFRC522.h>

#define SS_PIN 10
#define RST_PIN 9
MFRC522 mfrc522(SS_PIN, RST_PIN);

void setup() {
  Serial.begin(9600);
  SPI.begin();
  mfrc522.PCD_Init();
}

void loop() {
  if (!mfrc522.PICC_IsNewCardPresent())
    return;

  if (!mfrc522.PICC_ReadCardSerial())
    return;

  String uid = getCardId();
  
  Serial.println("RFID:" + uid);
  mfrc522.PICC_HaltA();
  delay(1000);
}

String getCardId() {
  String uid = "";
  for (byte i = 0; i < mfrc522.uid.size; i++)
  {
    uid.concat(String(mfrc522.uid.uidByte[i], HEX));
    if (i < mfrc522.uid.size - 1)
      uid.concat(" ");
  }
  uid.toUpperCase();
  return uid;
}

Fazit

In diesem Beitrag habe ich demonstriert, wie man einen eigenen Arduino RFID Scanner bauen kann. Dazu brauchten wir im ersten Schritt einen Arduino Mikrocontroller und das RFID Kit mit ein wenig Zubehör, wie einigen Jumper Kabeln. Zusätzlich brauchten wir die passende Klassenbibliothek, Welche Du unten unter Downloads herunterladen kannst. Nachdem wir dann alles im Setup vorbereiteten, haben wir mit einigen Funktionen der Library inkl. einer kleinen selbstgebauten Funktion die UID des jeweiligen Tags ausgelesen. Wenn Du wissen möchtest, wie Du diese Informationen nun in z. B. C# oder VB.NET verarbeiten kannst, schaue gerne in den unten aufgelisteten RFID Beitrag.

Weitere Links

• VB.NET RFID Chips mit Arduino auslesen
• Virtuelle COM Ports emulieren mit com0com

Downloads

Der Beitrag Chipkarten / Tags mit Arduino RFID Scanner auslesen erschien zuerst auf Robert Skibbe.