Das könnte Sie auch interessieren: Entwicklung eines Step-Down Moduls

Liste der Bauteile:

• 1x Battery Shield V3
• 6x Linsenkopfschrauben M2x8
• 1x Hohlstecker 5,5×2,1
• 6x Flachkopfschraube M2x6
• 1x LiPo Akku 18650

Untersuchung des Battery Shield V3

Nachdem das Battery Shield V3 bei mir angekommen war musste ich als erstes die Eigenschaften genau untersuchen.  Die Tests habe ich mir vorher überlegt und orientieren sich in erster Linie an meine Anwendungsfälle. Da ich natürlich kein Prüfinstitut bin habe ich die Tests so einfach wie möglich gehalten.

Zunächst habe ich die Hauptfunktion, das Aufladen eines LiPo Akkus, getestet. Der Ladevorgang am Modul wird mit Hilfe einer LED signalisiert. Rot bedeutet, dass der Akku aufgeladen wird und Grün bedeutet, dass der Ladevorgang beendet ist. Leider befinden sich die LEDs auf der Unterseite des Moduls und sind nicht gut sichtbar.

Laut den Angaben des Herstellers bzw. des online Händlers beträgt die Ladespannung 4,2 V und der Ladestrom 500 mA. Um diese Werte zu überprüfen, habe ich den Ladezustand des eingesetzten Akkus gemessen und notiert. Der Ladezustand war ungefähr bei 1100 mAh. Die gesamte Kapazität des Akkus beträgt 3000 mAh. Daraus folgt, dass die Differenz zwischen vollständig geladen und teilgeladen 1900 mAh beträgt. Um die vorraussichtliche Ladedauer zu erhalten, wird dieser Wert durch die vom Hersteller angegebenen 500 mA geteilt. Die berechnete Ladedauer ergab somit 4 h. Als Netzteil wird ein Standard Netzteil mit 5V und 1A Ladestrom verwendet. In der Realität betrug die Dauer des Ladens 4 h und 15 min. Das ist nahe an der Theorie und somit in Ordnung. 

Bitte beachten: Für diesen Test nie einen ganz neuen LiPo Akku verwenden, sondern einen der schon einige Ladezyklen hinter sich hat. Ansonsten ist das Ergebnis nicht sehr aussagekräftig. 

Untersuchung der Modul Spannungen

Im zweiten Test wurden die unterschiedlichen Spannungen untersucht, welche das Modul zur Verfügung stellt. Diesen Test habe ich in zwei Phasen unterteilt. In der ersten Phase (Bild Test 2_1) wird das Modul ohne LiPo Akku verwendet. Anschließend wird in der zweiten Phase ein LiPo Akku eingesetzt.

Wichtig ist hierbei natürlich die richtige Auswahl der Verbraucher, um den Test so realitätsnah wie möglich durchzuführen. Für den USB-A Anschluss habe ich sowohl einen Lastwiderstand mit 1 A als auch mit 2 A ausgewählt. Dieser keramische Lastwiderstand ist ideal, da eine USB Schnittstelle vorhanden ist und die LED grün leuchtet wenn 5 Watt verbraucht werden. Bei 10 Watt leuchtet die LED rot.

Für die 3 x 5 V Ausgänge habe ich an zwei Ausgängen 5V LED Streifen gelötet und am dritten 5V Ausgang hängt ein von mir konstruiertes Step-Down Modul LM2596S, das auf 2V eingestellt ist, um eine 10 mm RGB Led zu versorgen. An die 3 x 3 V Ausgängen wurden jeweils 3 V LEDs gelötet. Für diesen Test wurde ein 5 V (18 Watt) Netzteil verwendet.

Das Modul im Netzbetrieb ohne LiPo Akku

Es passierte eigentlich nach dem Anschließen der Verbraucher und den Netzteil nicht sonderlich viel. Es leuchtete nur die modulinterne LED rot. Erst als ich den Keramik-Lastwiderstand deaktiviert habe leuchtete einer der 5 V LED Streifen und die mit dem Step-Down verbundene RGB Diode (Gelb markiert in Bild Test2_1).

Bei der anschließenden Messung der Ausgänge wurden folgende Werte festgestellt: Bei den 5 V Ausgängen wurde eine Spannung von 3,24 V gemessen und bei den 3 V Ausgängen 2,28 V. Die gesamte Strombereitstellung des Moduls ohne eingesetzten LiPo Akku liegt bei ca. 11 mA. Das sollte für eine kleine LED ausreichen.

Das Modul mit LiPo Akku

Für die Phase 2 wurden alle Verbraucher entfernt und ein LiPo Akku (SAMSUNG INR18650-35E SDI KL59) in das Modul eingesetzt. Wie auf den Bildern zu erkennen ist wurden Steckverbindungen angebracht. Das liegt daran, dass dieses Modul keinen Schalter für den LiPo Akku besitzt und somit die Last sofort auf den LiPo Akku angelegt wird. Es ist einfach unangenehm einen Akku oder jegliche Batterie unter Last einzulegen bzw. einzustecken.

Alle Verbraucher sind in Phase 2 im Vollmodus und funktionieren einwandfrei. Zusätzlich wird sogar noch der LiPo Akku aufgeladen. Zweifel sind an den 5 V Ausgängen bezüglich der Ampereangaben (4 A) angebracht. Angesichts der Ampere Zahlen des LiPo Akkus ist das zwar möglich, aber es erscheint mir sehr hoch für eine USB Micro Versorgung. Meine Empfehlung ist das Modul mit weniger als 4 Ampere zu beanspruchen.

Tiefenentladeschutz

Der dritte und letzte Test ist eher trivial. Um den Tiefenentladeschutz zu prüfen wurde nur der Keramik Lastwiderstand mit 5 Watt aktiviert und keine Netzversorgung angeschlossen. Dadurch wird der LiPo Akku entladen und wenn der Tiefenentladeschutz des Moduls den Entladeprozess eigenständig beendet ist der Test erfolgreich. Das war der Fall. Es war genügend Restkapazität vorhanden. Allerdings sollten solche Stresssituationen für den LiPo Akku trotzdem vermieden werden. 

Gehäuse für das Battery Shield V3

Natürlich konnte ich es nicht lassen noch ein Gehäuse für das Battery Shield V3 Modul zu konstruieren. Neben dem normalen 5 V USB Ausgang, der über einen extra Schalter ein- und ausgeschalten werden kann, habe ich zusätzlich noch einen konstanten 3V Ausgang mit einer 5,5 x 2,1 Buchse  in das Gehäuse konstruiert.

Das Gehäuse kann am Ende des Blogbeitrags im STL-Format heruntergeladen werden.

Kleiner Nachteil

Der On/OFF Schalter schaltet nur den USB Port. Die 3 x 3 V und 3 x 5 V Lötstellen können nicht über diesen Schalter ein und ausgeschaltet werden.

Für meine Elektronik Projekte ist dieser Nachteil nicht wirklich dramatisch, da ich in erster Linie den USB Port nutze. Außerdem können an die Lötstellen auch zusätzliche Schalter eingelötet werden.

Dateien zum Herunterladen:

• Datenblatt Battery Shield V3 (von AZ Delivery)
• 3D Druck Gehäuse

The post Review Battery Shield V3 – Die DIY Powerbank mit LiPo Akku 18650 appeared first on Nerd Corner.

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.

Nachfolgend eine Erklärung wieso die Library „sys/time.h“ genutzt wurde, sowie ein Codebeispiel mit anschließender Erläuterung. Dieses Codebeispiel eignet sich sehr gut für bitweise Datenübertragung in der Kommunikationstechnik.

Das könnte Sie ebenfalls interessieren: Präzise Timer Interrupts für den Arduino programmieren!

Liste der Komponenten

• Linux Betriebssystem (zum Beispiel Raspberry Pi)
• Editor für C – Programmierung

Die Library „sys/time.h“

Funktionen wie „usleep()“ oder „nanosleep()“ würden das komplette Programm anhalten. Für einfache Anwendungen mag das vielleicht ausreichen, allerdings war das für meine Zwecke zu ungenau. Ich wollte einen Timer, der wirklich exakt im 1 ms Takt bzw. 0,1 ms Takt arbeitet. Deswegen wurde anstelle von „usleep()“ oder „nanosleep()“ eine andere Lösung gewählt. Die Library „sys/time.h“. Diese kann die aktuelle „System Clock Time“ (System Uhrzeit) auslesen und vergleichen.

Codebeispiel für präzisen Timer in C

#include <sys/time.h>

int main()
{
    struct timeval tval_before, tval_after, tval_result;
    int counter=0;
    bool stop=false;
   
    gettimeofday(&tval_before, NULL);
    while(stop!=true)
    {
        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)  //1ms; you can change your desired time interval here
        {
            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);
        
        if (counter==10000)
        {
            stop=true;
        }
            
        else 
        {
            counter++;
        }
    }
    return 0;
}

Erklärung zum Codebeispiel:

Eine Funktion „gettimeofday“ schreibt die aktuelle System Uhrzeit in die Variable „tval_before“. Eine While Schleife wird anschließend solange ausgeführt bis die eigentliche Aufgabe erledigt ist.

Innerhalb der While Schleife wird als Erstes erneut die System Uhrzeit in eine Variable „tval_after“ abgespeichert. Anschließend wird die zeitliche Differenz zwischen „tval_after“ und „tval_before“ gemessen und in „tval_result“ abgespeichert.

Der nächste Schritt des Timers in C erschließt sich nicht sofort auf den ersten Blick: „tv_result“ besteht per Definition aus 2 Teilen. Zum einen ein Sekunden Anteil „.tv_sec“ und zum anderen ein Mikrosekunden Anteil „.tv_usec“. Eben dieser Mikrosekundenanteil muss erst noch durch eine Million geteilt werden, damit man den Wert in Sekunden erhält. Anschließend, kann der Mikrosekundenanteil zum Sekundenanteil addiert werden.

Der addierte Wert wird im Code als „time_elapsed“ bezeichnet. Falls dieser Wert kleiner als eine Millisekunde ist, wird eine weitere innere While Schleife geöffnet, die solange den Wert für „time_elapsed“ neu berechnet, bis exakt 1 ms vergangen ist. Anschließend wird mittels der „gettimeofday“ Funktion der Wert für „tval_before“ neu festgelegt.

Da zu diesem Zeitpunkt exakt 1 ms vergangen ist, kann der Timer nun seinen eigentlichen Arbeitsschritt ausführen. In diesem einfachen Codebeispiel wird lediglich eine Variable „counter“ um 1 erhöht. Das bedeutet für jeden Intervallschritt (im Codebeispiel 1 ms) erhöht sich der counter um 1. Sobald ein festgelegter Wert für counter erreicht wurde stoppt das Programm. In diesem Fall ist der festgelegte Wert 10000. Anschließend wird die While Schleife beendet. Aber dieser Teil des Codes kann natürlich problemlos für die eigenen Zwecke angepasst werden.

Meine Messungen mit dem Oszilloskop haben eine exakte Frequenz von 1 ms gemessen, sogar 0,1 ms wurde exakt gemessen. Dieses Codebeispiel eignet sich deswegen auch sehr gut für eine exakte Datenübertragung in der Kommunikationstechnik.

Dateien herunterladen

• Downloadfile Timer in C

The post Wie programmiert man einen präzisen Timer in C für Linux appeared first on Nerd Corner.