This might also be interesting for you: Development of a step-down module

List of components:

• 1x Battery Shield V3
• 1x LiPo 18650

Analysis of the Battery Shield V3

After the Battery Shield V3 arrived, the first thing I had to do was examine its properties in detail.  I thought about the tests beforehand and they were primarily based on my use cases. Since I am of course not a research institute, I kept the tests as simple as possible.

First, I tested the main function, which is charging a LiPo battery. The charging process on the module is indicated by a LED. Red means that the battery is charging and green signifies that charging is complete. Unfortunately, the LEDs are located on the bottom of the module and are therefore not easily visible.

According to the information provided by the manufacturer or the online retailer, the charging voltage is 4.2 V and the charging current is 500 mA. To verify these values, I measured and noted the state of charge of the inserted battery. The state of charge was approximately at 1100 mAh. The total capacity of the battery is 3000 mAh. It appears that the difference between fully charged and partially charged is 1900 mAh. To get the expected charging time, this value is divided by the 500 mA specified by the manufacturer. The calculated charging time is therefore 4 h. A standard power supply with 5V and 1A charging current is used as the power supply. In reality, the duration of charging was 4 h and 15 min. This is close to the theoretical value and thus okay.

Please note: Never use a brand new LiPo battery for this test, instead use one that already has some charge cycles completed. Otherwise, the result is not very meaningful.

Voltage testing in the Review Baterry Shield V3

In the second test, the different voltages provided by the module were examined. I divided this test into two phases. In the first phase (picture test 2_1) the module is used without a LiPo battery. Afterwards in the second phase a LiPo battery is used.

Of course, it is important to choose the right components to make the test as realistic as possible. For the USB-A connection I selected a load resistor with 1 A as well as with 2 A. This ceramic load resistor is ideal because a USB interface is available and the LED lights up green when 5 watts are consumed. At 10 watts the LED lights red.

For the 3 x 5 V outputs, I soldered 5V LED strips to two outputs and the third 5V output has a step-down module LM2596S which I constructed and set to 2V to power a 10 mm RGB Led. 3 V LEDs were soldered to each of the 3 x 3 V outputs. For this test a 5 V (18 Watt) power supply was used.

The module operating without LiPo battery

After connecting the consumers and the power supply, not much happened. Only the module-internal LED lit up red. Only when I deactivated the ceramic load resistor one of the 5 V LED strips and the RGB diode connected to the step-down (marked yellow in picture Test2_1) lit up.

Subsequent measurement of the outputs revealed the following values: A voltage of 3.24 V was measured for the 5 V outputs and 2.28 V for the 3 V outputs. The total current supply of the module without the LiPo battery inserted is about 11 mA. This should be sufficient for a small LED.

The module with LiPo battery

For phase 2 all consumers were removed and a LiPo battery (SAMSUNG INR18650-35E SDI KL59) was inserted into the module. As shown in the pictures, connectors were attached. This is because this module does not have a switch for the LiPo battery, so the load is immediately applied to the LiPo battery. It is simply uncomfortable to insert or plug in a battery under load.

All loads are in full mode in phase 2 and work fine. In addition, even the LiPo battery is charged. Questionable are the 4A amperage specifications of the 5V outputs. Given the amp numbers of the LiPo battery, this is possible, but it seems very high for a USB Micro supply. My recommendation would be to use the module with less than 4 amps.

Deep discharge protection

The third and last test is rather trivial. To test the deep discharge protection, only the ceramic load resistor with 5 watts was activated and no power supply was connected. This discharged the LiPo battery and if the deep discharge protection of the module terminates the discharge process on its own, the test was successful. This was the case. There was enough remaining capacity. However, such stress situations for the LiPo battery should still be avoided.

Casing for the Battery Shield V3

Of course I couldn’t resist to build a case for the Battery Shield V3 module. Beside the normal 5V USB output, which can be switched on and off by an extra switch, I also constructed a constant 3V output with a 5,5 x 2,1 socket into the case.

The housing can be downloaded in STL format at the end of the blog post.

Minor disadvantages

The On/OFF switch only switches the USB port. The 3 x 3 V and 3 x 5 V solder pins cannot be switched on and off by this switch.

For my electronic projects this disadvantage is not really dramatic, because I use mostly the USB port. Besides, additional switches can be soldered to the soldering points.

Downloading files:

• Datenblatt Battery Shield V3 (von AZ Delivery)
• STL Files for the housing

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

This might also be interesting for you: Sending text messages with light signals

Closely related to this article: Error detection during data transmission

Also relevant: Precise Timer in C for data transfer

List of components

• 2x Raspberry Pi 4
• 2x 5V Solar cell
• 2x 5V Laser diode
• Jumper cables
• 3D printer
• Filament
• 2x 5V Fan
• NPN Transistor
• 2x ADC Board with a LM393 dual comparator

Wiring

Unlike the wiring in the last article, where text messages were sent from a Pi to an Arduino via light signals ( Link: https://nerd-corner.com/sending-text-messages-with-visible-light-communication/ ), there is now no defined receiver and no defined transmitter. Instead, two identical stations are set up that can both send and receive data.

For this reason, the Raspberry Pi’s are connected to both a 5V laser and a 5V solar cell. For the laser the GPIO18 pin was chosen, which corresponds to pin 1 in the “wiringPi” library. The “wiringPi” library is used in the program code. Directly below GPIO18 is a ground, which is connected to the negative pole of the laser.

The solar cell provides a corresponding voltage value depending on the light intensity. But since the digital pins of the Raspberry Pi can only recognize 1 and 0, the analog value of the solar cell must be converted into a digital value with the help of a comparator. The process is explained in more detail in the section “ADC Board with an LM393 Comparator”. For the wiring, the plus and minus pole of the solar cell is connected to the plus and minus contacts of the ADC board. Then the ground of the ADC board is connected to a Raspberry Pi ground and for the power supply the plus pole of the ADC board is connected to 5V of the Pi. The D0 pin of the ADC board provides the digital value 0 or 1, depending on the light intensity of the solar cell. I connected this pin to GPIO17, which corresponds to pin 0 in the “wiringPi” library.

Since I noticed that the Pi gets very hot during operation, I connected a fan. So that the fan is not permanently in operation, which would have a negative effect on the performance of the laser, the fan can be switched on and off by a NPN transistor. Connect the positive pole of the fan directly to a 5V pin of the Raspberry Pi and the negative pole of the fan to the emitter of the NPN transistor. The collector of the transistor is connected to a ground of the Pi. To switch the fan on and off via the transistor, the transistor base is connected to a GPIO pin. For example I chose GPIO27 (corresponds to pin 2 in the “wiringPi” library). In the following table the pins of the Pi are compared to the numbering of the “wiringPi” library.

ADC Board with a LM393 camparator

The solar cell returns a voltage value depending on the light intensity. Unfortunately the Raspberry Pi has no analog pins to read this voltage value. Therefore the analog signal has to be converted into a digital signal. This is possible with the help of the LM393 comparator. The comparator is often used on ADC boards. Here I simply replaced the original sensor (it was a photoresistor) through a solar cell. With the help of a potentiometer the comparator can be adjusted. That means, as soon as the voltage value of the solar cell, which depends on the light intensity, exceeds the adjusted value of the potentiometer, a digital 1 is measured, otherwise a digital 0.

Structure of the data frame

The data frame for sending the text messages using visual light communication (Link: https://nerd-corner.com/sending-text-messages-with-visible-light-communication/ ) consisted of a preamble, the length of the text message, the text content and the cyclic redundancy check. However, to be able to send all kinds of data instead of text messages, the file name, the file extension, the total number of packets and the number of the current packet must be specified instead of the length of the text message. Then the data content and the code of the cyclic redundancy check can be added.

Software code for data transfer via VLC

Basically, the receiver and sender scripts from the previous project on sending text messages using visual light communication (link: https://nerd-corner.com/de/textnachrichten-mittels-lichtsignale-senden-pi-zu-arduino/ ) were further developed and combined into one single script. Which is applied on both Raspberry Pi’s. For example, a “ReadFile” and “WriteFile” function was added, which can read files and combine and save received data packets to a file. The program was written in C again, because a high speed of data transfer should be achieved. Details about precise programming in C for fast data transfer are given in this article: https://nerd-corner.com/how-to-program-a-highly-precise-timer-in-c-for-linux/ .

The complete software code for data transfer using VLC can be downloaded at the end of the article. The core of the program is again a state machine with the help of which can be selected whether data should be sent or received. In addition, the program automatically turns on the fan when no data transfer is taking place. Important: When compiling please do not forget the “wiringPi” library and the “math.h” library! The command is: “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 Moden");
        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 sizen");
                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;
                  
            }
            
        }
    }

Housing

In order to be able to hold the components in place, a housing was constructed in CAD. This also has the advantage that no complicated alignment of the lasers and the solar cells is necessary for the data transmission. For beginners, TinkerCAD is suitable for housing design. TinkerCAD is free and can be used directly in the browser. Alternatively, the STL files for the 3D printer can also be downloaded here.

The housing for data transfer via VLC has an opening for the solar cell and the laser. In addition, an exhaust vent for the fan was constructed and space was also left free for a Raspberry Pi housing. The following picture shows the installation of the components.

Conclusion about data transfer via VLC

The existing system for sending text messages by means of visual light signals was further developed so that all types of data can now be sent and received. The system works amazingly successfully. It is very robust and achieves a data rate of 1 kbps to 10 kbps. All incoming data packets can be directly assigned due to the intelligent structure of the data frame. Only an acknowledgement signal would be a useful addition. Such a signal would be a feedback from the receiver to the sender to inform the sender that all packets have arrived, or possibly a certain packet was faulty and must be sent again.

Also interesting for the future would be to investigate other types of modulation. In particular, I would like to explore color shift keying, which is specifically designed for visual light communication, and compare the resulting data rates.

Download files:

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

The post Upgrade: Data transfer via VLC and LiFi – Pi to Pi transfer appeared first on Nerd Corner.

In the following is an explanation why the library “sys/time.h” was used, as well as a code example with subsequent explanation. This code example is very well suited for bit-wise data transmission in communication technology.

This might also be interesting for you: How to program a highly precise Arduino Timer

List of components

• Linux operating system (for example Raspberry Pi)
• Editor for C – Programming

The library „sys/time.h“

Functions like “usleep()” or “nanosleep()” would stop the complete program. For simple applications this might be sufficient, but for my purposes this was too imprecise. I wanted a timer that really works exactly in a 1 ms or 0.1 ms cycle. So instead of “usleep()” or “nanosleep()” another solution was chosen. The library “sys/time.h”. This library is able to read and compare the current “System Clock Time”.

Code example for a precise 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;
}

Explanation of the code example:

A function “gettimeofday” writes the current system time into the variable “tval_before”. A While loop will then be executed until the actual task is completed.

Within the While loop the system time is stored again into a variable “tval_after”. Then the time difference between “tval_after” and “tval_before” is measured and stored in “tval_result”.

The next step of the timer in C is not immediately obvious: “tv_result” consists by definition of 2 parts. On the one hand a seconds part “.tv_sec” and on the other hand a microseconds part “.tv_usec”. This microsecond part has to be divided by one million to get the value in seconds. Afterwards, the microsecond part can be added to the second part.

The added value is called “time_elapsed”. If this value is less than one millisecond, another inner While loop is opened, which recalculates the value for “time_elapsed” until exactly 1 ms has passed. Afterwards, the value for “tval_before” is redefined using the “gettimeofday” function.

Since exactly 1 ms has passed at this point, the timer can now perform its actual operation. In this simple code example the variable “counter” is incremented by 1. That means for each interval step (in the code example 1 ms) the counter increases by 1. As soon as a fixed value for counter was reached the program stops. In this case the defined value is 10000. Then the While loop will be terminated. But this part of the code can be easily changed for your own purposes.

My measurements with an oscilloscope detected an exact frequency of 1 ms, even 0.1 ms was measured exactly. This code example is therefore also very suitable for an exact data transmission in the communication technology.

Download files

• Downloadfile Timer in C

The post How to program a highly precise timer in C for Linux appeared first on Nerd Corner.