Das könnte dich auch interessieren: Textnachrichten mittels Lichtsignale senden

Eng mit diesem Artikel verbunden: Fehlererkennung bei der Datenübertragung

Ebenfalls relevant: Taktgeschwindigkeit für eine Datenübertragung festlegen in C

Liste der Bauteile

• 2x Raspberry Pi 4
• 2x 5V Solarzelle
• 2x 5V Laserdiode
• Jumper Kabel
• 3D Drucker
• Filament
• 2x 5V Lüfter
• NPN Transistor
• 2x ADC Board mit einem LM393

Verkabelung

Anders als bei der Verkabelung im letzten Artikel, in dem Textnachrichten mittels Lichtsignale von einem Pi zu einem Arduino gesendet wurden ( Link: https://nerd-corner.com/de/textnachrichten-mittels-lichtsignale-senden-pi-zu-arduino/ ), gibt es jetzt keinen definierten Empfänger und keinen definierten Sender. Es werden stattdessen zwei baugleiche Stationen aufgebaut, die sowohl Daten senden und empfangen können.

Aus diesem Grund werden die Raspberry Pi’s sowohl mit einem 5V Laser als auch mit einer 5V Solarzelle verbunden. Für den Laser wurde der GPIO18 Pin gewählt, welcher in der „wiringPi“ Library Pin 1 entspricht. Die „wiringPi“ Library wird im Programmcode verwendet. Direkt unter GPIO18 befindet sich ein Ground, welcher mit dem Minus Pol des Lasers verbunden wird.

Die Solarzelle liefert je nach Lichtintensität einen entsprechenden Spannungswert. Da die digitalen Pins des Raspberry Pi aber nur 1 und 0 erkennen können, muss mit Hilfe eines Komparators der analoge Wert der Solarzelle in einen digitalen Wert gewandelt werden. Der Vorgang wird genauer im Abschnitt „ADC Board mit einem LM393 Komparator“ erläutert. Für die Verkabelung wird der Plus und Minus Pol der Solarzelle mit den Plus und Minus Kontakten des ADC Boards verbunden. Anschließend wird der Ground des ADC Boards an einen Raspberry Pi Ground verbunden und für die Spannungsversorgung der Plus Pol des ADC Boards mit 5V des Pi verbunden. Der D0 Pin des ADC Boards liefert den digitalen Wert 0 oder 1, abhängig von der Lichtintensität der Solarzelle. Diesen Pin habe ich mit GPIO17, welcher in der „wiringPi“ Library Pin 0 entspricht, verbunden.

Da mir aufgefallen ist, dass der Pi im Betrieb sehr heiß wird, habe ich noch einen Lüfter angeschlossen. Damit der Lüfter sich nicht dauerhaft im Betrieb befindet, was sich negativ auf die Leistung des Lasers auswirken würde, kann der Lüfter durch einen NPN Transistor geschalten werden. Hierfür verbindet man den Plus Pol des Lüfters direkt mit einem 5V Pin des Raspberry Pi und den Minus Pol des Lüfters mit dem Emitter des NPN Transistors. Der Collector des Transistors wird mit einem Ground des Pi verbunden. Um nun den Lüfter über den Transistor ein- und ausschalten zu können wird die Transistor Basis mit einem GPIO Pin verbunden. Ich habe beispielsweise GPIO27 (entspricht in der „wiringPi“ Library Pin 2) gewählt. In der Nachfolgenden Tabelle werden die Pins des Pi der Nummerierung der „wiringPi“ Library gegenüber gestellt.

ADC Board mit einem LM393 Komparator

Die Solarzelle gibt abhängig von der Lichtintensität einen Spannungswert zurück. Leider hat der Raspberry Pi aber keine analogen Pins um diesen Spannungswert auszulesen. Daher muss das analoge Signal in ein digitales Signal umgewandelt werden. Mit Hilfe des LM393 Komparators ist das möglich. Dieser ist häufig auf ADC Boards verbaut. Hier habe ich einfach den ursprünglichen Sensor (es war ein Fotowiderstand) durch die Solarzelle ersetzt. Mit Hilfe eines Potentiometers kann der Komparator eingestellt werden. Das bedeutet, sobald der Spannungswert der Solarzelle, welcher von der Lichtintensität abhängt, den eingestellten Wert des Potentiometers übersteigt, wird eine digitale 1 gemessen, anderenfalls eine digitale 0.

Aufbau des Datenframes

Der Datenframe für das Versenden der Textnachrichten mittels visueller Lichtkommunikation (Link: https://nerd-corner.com/de/textnachrichten-mittels-lichtsignale-senden-pi-zu-arduino/ ) bestand aus einer Preamble, der Länge der Textnachricht, dem Textinhalt und der zyklischen Redundanzprüfung. Um aber statt Textnachrichten alle möglichen Arten von Daten verschicken zu können muss anstelle der Länge der Textnachricht der Dateiname, die Dateiendung, die Gesamtzahl der Pakete und die Nummer des aktuellen Pakets angegeben werden. Anschließend kann der Dateninhalt und der Code der zyklischen Redundanzprüfung angefügt werden.

Softwarecode für Datentransfer mittels VLC

Im Grunde wurden die Empfänger- und Senderskripte aus dem vorherigen Projekt zum Senden von Textnachrichten mittels visueller Lichtkommunikation (Link: https://nerd-corner.com/de/textnachrichten-mittels-lichtsignale-senden-pi-zu-arduino/ ) weiterentwickelt und zu einem gemeinsamen Skript zusammengefasst. Welches auf beiden Raspberry Pi’s Anwendung findet. Es wurde beispielsweise eine „ReadFile“ und „WriteFile“ Funktion ergänzt, welche Dateien einlesen und empfangene Datenpakete zu einer Datei zusammenfassen und abspeichern können. Das Programm wurde wieder in C geschrieben, da eine hohe Geschwindigkeit bei der Datenübertragung erreicht werden soll. Details zur präzisen Programmierung in C für eine schnelle Datenübertragung in diesem Beitrag: https://nerd-corner.com/de/wie-programmiert-man-einen-praezisen-timer-in-c-fuer-linux/

Der gesamte Softwarecode zum Datentransfer mittels VLC kann am Ende des Artikels heruntergeladen werden. Der Kern des Programms ist wieder eine State Maschine mit Hilfe derer ausgewählt werden kann, ob Daten gesendet oder empfangen werden sollen. Außerdem schaltet das Programm automatisch den Lüfter an, wenn keine Datenübertragung stattfindet. Wichtig: Beim Kompilieren bitte nicht die „wiringPi“ Bibliothek und die „math.h“ Bibliothek vergessen! Der Befehl lautet: „gcc -o transceiver transceiver.c -lwiringPi -lm“

while(1)
    {
        digitalWrite (2, HIGH);
        printf("Press the R button for Receiver Mode or any other key for Sender Mode\n");
        scanf(" %c",&mode);
        
        if (mode=='R'||mode=='r')
        {
            digitalWrite(2,LOW);
            modeReceiver=true;
        }
        
        if (mode!='R'&&mode!='r')
        {
            digitalWrite(2,LOW);
            modeReceiver=false;
            
            char dataName[NAME_MAX];
            char dataExtension[NAME_MAX];
            
               
            printf("\n Name of file WITHOUT extension: ");
            scanf("%s",dataName);

            printf("\n Extension: ");
            scanf("%s",dataExtension);

            if (read_file(dataName, dataExtension, file_content) != OK)
            {
                printf("File read error, size exceeds array size\n");
                return -1;
            }
            BuildDataFrame(dataName, dataExtension, file_content);
        }
        
        
        
        while(modeReceiver)
        {
            gettimeofday(&tval_after, NULL);
            timersub(&tval_after, &tval_before, &tval_result);
            double time_elapsed = (double)tval_result.tv_sec + ((double)tval_result.tv_usec/1000000.0f);
            
            while(time_elapsed < 0.001)
            {
                gettimeofday(&tval_after, NULL);
                timersub(&tval_after, &tval_before, &tval_result);
                time_elapsed = (double)tval_result.tv_sec + ((double)tval_result.tv_usec/1000000.0f);
            }
            gettimeofday(&tval_before, NULL);
            
            int data = digitalRead(0);
            
            
            switch (state)
            {
                case 0:
                    //looking for preamble pattern
                    synchro_Done=false;
                    LookForSynchro(data);
                    
                    if (synchro_Done==true)
                    {
                        state=1;
                    }
                    break;
                    
                case 1:
                    //receive the actual data
                    receiveData_Done=false;
                    senderState=false;
                    ReceiveData(data);
                    
                    if(receiveData_Done&&senderState==false)
                    {
                        state=0;
                    }
                    if(senderState==true){
                        senderState=false;
                        state=0;
                        modeReceiver=false;
                        }
                    break;
                  
            }
            
        }
    }

Gehäuse

Um die Komponenten an Ort und Stelle fixieren zu können, wurde im CAD ein Gehäuse konstruiert. Dies hat auch den Vorteil, dass keine komplizierte Ausrichtung der Laser und der Solarzellen für die Datenübertragung notwendig ist. Für Anfänger eignet sich TinkerCAD zum Gehäuse design. TinkerCAD ist kostenlos und kann direkt im Browser benutzt werden. Alternativ können die STL Files für den 3D Drucker auch hier heruntergeladen werden.

Das Gehäuse zum Datentransfer mittels VLC besitzt eine Öffnung für die Solarzelle und den Laser. Außerdem wurde ein Abluftschacht für den Lüfter konstruiert und zusätzlich Platz für ein Raspberry Pi Gehäuse frei gelassen. Im nachfolgenden Bild wird der Einbau der Komponenten dargestellt.

Fazit zum Datentransfer mittels VLC

Es wurde das bereits bestehende System zum Senden von Textnachrichten mittels visueller Lichtsignale weiterentwickelt, sodass jetzt alle Arten von Daten gesendet und empfangen werden können. Das System funktioniert erstaunlich erfolgreich. Es ist sehr robust und erreicht eine Datenrate von 1 kBit/s bis 10 kBit/s. Alle ankommenden Datenpakete können durch den intelligenten Aufbau des Datenframes direkt zugeordnet werden. Lediglich ein Acknowledgement Signal wäre noch eine sinnvolle Ergänzung. Ein solches Signal wäre eine Rückmeldung vom Empfänger an den Sender um dem Sender mitzuteilen, dass alle Pakete angekommen sind, oder eventuell ein bestimmtes Paket fehlerhaft war und erneut gesendet werden muss.

Ebenfalls interessant für die Zukunft wäre andere Modulationsarten auszuprobieren. Besonders das speziell für visuelle Lichtkommunikation erdachte Colour Shift Keying würde ich gerne näher untersuchen und die daraus resultierenden Datenraten vergleichen.

Dateien herunterladen:

• Softwarecode Transceiver
• STL files housing
• Pi Case with free pins (Creative Common License from Thingiverse)

The post Upgrade: Datentransfer mittels VLC und LiFi – Pi zu Pi Übertragung appeared first on Nerd Corner.

In diesem Beitrag zeigen wir dir wie sich die Drehzahl des Lüfters über die Spannung steuern lässt. Hierfür benötigt man lediglich die + und – Anschlüsse des Lüfters. Auch wenn es sich bei deinem Lüfter um einen Computerlüfter mit 3 oder 4 Anschlüssen handelt, brauchst du nur die + und – Anschlüsse.

Da wir hier mit einem 12V Lüfter arbeiten und der Arduino maximal 5V Ausgangsspannung leisten kann, ist eine externe Stromversorgung notwendig. Solltest du mit einem 5V Lüfter arbeiten, dann reicht natürlich die Ausgangsspannung des Arduino.

Das könnte Dich auch interessieren: Arduino per Bluetooth App steuern.

Liste der Bauteile

• Arduino Mega
• Steckbrett
• 12V Spannungsversorgung
• 12V Lüfter
• Jumper Kabel
• 220 Ohm Widerstand
• NPN Transistor

Verkabelung der Arduino Lüfter Steuerung

Für die Verkabelung gehen wir entsprechend der Skizze vor. Die 12V Spannungsversorgung wird an das Breadboard angeschlossen. Wir verbinden das – des Breadboards mit GND des Arduinos (kurze blaue Kabelverbindung im Bild). Anschließend wird das + des Breadboards mit Vin des Arduino Megas verbunden (rotes Kabel zwischen Arduino und Breadboard).

Würden wir unsere 12V Spannungsversorgung in die Steckdose stecken. Dann wäre unser Arduino jetzt bereits mit Strom versorgt. Es ist keine zusätzliche Stromversorgung für den Arduino notwendig. Der Vin Eingang reguliert die 12V automatisch auf die notwendigen 5V für den Arduino.

Ins Breadboard stecken wir jetzt unseren NPN Transistor. Die Basis (B) verbinden wir mit dem 220 Ohm Widerstand und anschließend auf den Pin 13 (gelbe Verbindung im Bild). Den Kollector (C) des Transistors verbinden wir direkt mit dem negativen Anschluss des Lüfters (schwarzes Lüfter Kabel). Der positive Lüfteranschluss wird mit dem + des Breadboards verbunden. Den Emitter (E) des Transistors verbinden wir mit dem – des Breadboards. Jetzt fehlt nur noch der Arduino Code.

Der Code für die Arduino Lüfter Steuerung

Der Arduino Code ist absolut simpel und lässt sich ohne großen Aufwand in jedes bestehende Arduino Programm integrieren. Da wir die Basis des Transistors mit Pin 13 verbunden haben, definieren wir diesen als „motorPin“. Über die Variable „speed“ lässt sich dann die Drehzahl des Lüfters steuern. Für die Drehzahl kann ein Wert zwischen 0 und 255 gewählt werden. Je nach Lüfter Modell ist aber eine Mindestdrehzahl notwendig, damit der Lüfter anläuft.

The post Arduino Lüfter Steuerung appeared first on Nerd Corner.

Das könnte Dich auch interessieren: Wie man eine Arduino Lüftersteuerung programmiert.

Liste der Bauteile

• Arduino Mega
• Steckbrett
• 12V Spannungsversorgung
• 12V Lüfter
• Jumper Kabel
• 220 Ohm Widerstand
• NPN Transistor
• Bluetooth Modul HC-05 oder HC-06

Verkabelung

Für die Verkabelung gehen wir analog zu unserem ersten Beitrag zur Lüfter Steuerung vor. 12V Spannungsversorgung wird an das Breadboard angeschlossen. Wir verbinden das – des Breadboards mit GND des Arduinos (kurze blaue Kabelverbindung im Bild). Anschließend wird das + des Breadboards mit Vin des Arduino Megas verbunden (rotes Kabel zwischen Arduino und Breadboard).

Würden wir unsere 12V Spannungsversorgung in die Steckdose stecken. Dann wäre unser Arduino jetzt bereits mit Strom versorgt. Es ist keine zusätzliche Stromversorgung für den Arduino notwendig. Der Vin Eingang reguliert die 12V automatisch auf die notwendigen 5V für den Arduino.

Ins Breadboard stecken wir jetzt unseren NPN Transistor. Die Basis (B) verbinden wir mit dem 220 Ohm Widerstand und anschließend auf den Pin 13 (gelbe Verbindung im Bild). Den Kollector (C) des Transistors verbinden wir direkt mit dem negativen Anschluss des Lüfters (schwarzes Lüfter Kabel). Der positive Lüfteranschluss wird mit dem + des Breadboards verbunden. Den Emitter (E) des Transistors verbinden wir mit dem – des Breadboards.

Zusätzlich zu diesen bereits bekannten Schritten nehmen wir das Bluetooth Modul und verbinden Ground des Moduls mit Ground vom Arduino (schwarze Verbindung). VCC des Moduls wird mit 3,3V des Arduinos Verbunden (rote Verbindung). Falls kein 3,3V Anschluss vorhanden ist, kann auch der 5V Anschluss benutzt werden. TX des Bluetooth Moduls muss mit RX des Arduinos verbunden werden (oranges Kabel). RX des Moduls muss mit TX des Arduinos verbunden werden (lilanes Kabel). Also TX zu RX und RX zu TX. Also immer zum Pendant.

Wichtig: Während der Arduino Code auf den Arduino geflasht wird muss man RX und TX abstecken. Ansonsten funktioniert der Flashvorgang nicht!

Programmierung der Android Bluetooth Classic App für den Arduino

Wir programmieren eine reine Android App mit einem HC-05 oder alternativ HC-06 Bluetooth Modul. Es handelt sich dabei um Bluetooth Classic Module. Sie können kein Bluetooth 4.0 auch Bluetooth Low Energy (BLE) genannt. Für BLE würde unser Code ganz anders aussehen. Nachfolgend die Anleitung zur Programmierung. Alle wichtigen Dateien werden ebenfalls hochgeladen.

Als Entwicklungsumgebung für die Bluetooth App Arduino Steuerung nutzen wir Visual Studio (kostenlos) für eine Xamarin.Android App. In AndroidStudio ist der Ablauf analog, allerdings ist der Code dann in Java und nicht in C#.

Auf „Neues Projekt erstellen“ klicken und „Android-App (Xamarin)“ auswählen. Zunächst ergänzen wir die Bluetooth Berechtigungen zur „AndroidManifest.xml“ Datei:

<uses-permission android: name = "android.permission.BLUETOOTH" />
<uses-permission android: name = "android.permission.BLUETOOTH_ADMIN" />

Anschließend gestalten wir das Layout der Bluetooth App Arduino Steuerung in der „activity_main.xml“ Datei. Wir brauchen 2 Buttons für „Connect“ und „Disconnect“ und einen Slider für die Drehzahlregulierung. Für den Slider setzen wir den Maximalwert auf 255 (android:max=“255″).

In der „MainActivity.cs“ fügen wir „using Android.Bluetooth“ hinzu, legen eine „BluetoothConnection“ Klasse an und setzen unsere „activity_main.xml“ Datei als Startseite. Es wird ein Bluetooth Socket kreiert für die Verbindung zum Arduino. Den exakten Code am besten aus der beigefügten Datei entnehmen. Im Wesentlichen senden wir immer ein Byte zum Arduino. Das bedeutet wir können so Zahlen zwischen 0 und 255 senden. Für die Lüfter Steuerung nehmen wir den Bereich von 0 bis 127. Der Arduino verdoppelt diesen Wert und reguliert so den Lüfter der ebenfalls in einem Bereich zwischen 0 und 255 läuft. Der restliche Bereich zwischen 128 und 255 kann für weitere Funktionen genutzt werden. Jetzt nur noch die App kompilieren und schon haben wir sie auf unserem Handy.

Der Code für die App basiert übrigens auf diesem Projekt hier: https://www.instructables.com/id/3-LED-Backlight-Xamarin-and-Arduino-With-HC05/

Arduino Code

#define motorPin 13
int received; //for the received Byte
int fanSpeed = 127; //initial speed - must be a number between 0 and 255
void setup() {
  Serial.begin(9600); //for communication with the app
  delay(3000); // small delay
  pinMode(motorPin, OUTPUT); //define motor pin as output
  analogWrite(motorPin,fanSpeed); //set the initial speed of the fan
}
void loop() {  
  while(Serial.available()) 
  {
     received = Serial.read(); //received Byte    
     Serial.println(received); //if the arduino is connected to the PC, than you can check the received Byte
     switch (received)  //you can easily add new cases to customize your arduino
     {
        case 200:
            Serial.println("RESTARTED");
            break;
        default:
            if(received >0 && received <=127)
            {
              fanSpeed = (received*2); //app sends value between 0 and 127 - so we need to double it for the fan range between 0 and 255
              delay(10);
            }
            break;
     }  
  }
  analogWrite(motorPin,fanSpeed); //set the speed of the fan
}

Bitte nicht vergessen vor dem Flashen des Arduino die RX und TX Verbindung abzuziehen und danach wieder richtig zu verbinden (RX zu TX und TX zu RX)!

Da wir die Basis des Transistors mit Pin 13 verbunden haben, definieren wir diesen als „motorPin“. Über die Variable „fanSpeed“ lässt sich dann die Drehzahl des Lüfters steuern. Zu Beginn setzen wir „fanSpeed“ auf die halbe Geschwindigkeit, also 127. (Je nach Lüfter Modell ist eine gewisse Mindestdrehzahl notwendig, damit der Lüfter anläuft.)

Wir definieren uns eine Variable „received“ in der wir das von der App gesendete Byte speichern. In der setup-Funktion starten wir die Kommunikation mit „Serial.begin“ und setzen die Baudrate auf 9600. Anschließend programmieren wir eine while-Schleife in der loop-Funktion. Die while-Schleife wird aktiv immer wenn ein Byte empfangen wird. Sollte der Wert des Bytes zwischen 0 und 127 liegen, dann verdoppeln wir diesen und definieren ihn als unsere neue Lüfter Drehzahl „fanSpeed“. Sobald die while-Schleife beendet ist wird die neue Geschwindigkeit für den Lüfter eingestellt mit „analogWrite(motorPin,fanSpeed);“

Screenshots der Bluetooth App Arduino Steuerung

Bitte beachten, man muss sich zuerst in den Einstellungen mit dem Bluetooth Modul verbinden für die Bluetooth App Arduino Steuerung. Erst danach kann man sich in der App mit dem Arduino verbinden!

Download files

• Source Code Android App "FanControllerBluetooth"
• Arduino Code for the "FanControllerBluetooth" app
• Only MainActivity.cs AndroidMainfest.xml and activity_main.xml of the "FanControllerBluetooth" app

The post Android Bluetooth classic App zur Arduino Steuerung (Lüfter) appeared first on Nerd Corner.