Build a Saltwater Battery

Clean Power

Rechargeable lithium batteries are expensive, and manufacturing them damages the environment. Saltwater batteries offer a cheaper and greener approach to storing energy.

The supply of lithium is finite, mining lithium pollutes the environment, and the batteries are expensive. None of this applies to saltwater batteries. Common household utensils are all you need to build one for yourself.

Energy turnaround and environmental benefits are some of today’s central topics. However, it is not just a matter of making energy production more green but of looking at all aspects of the energy industry. It makes no sense to store clean solar power in lithium-ion batteries if producing them causes massive environmental damage. Recycling these batteries is also problematic. For stationary use, the saltwater battery offers a truly ecological alternative.

Everyone is shaped by their knowledge and experiences. When I first heard about storing energy in saltwater batteries, my first thought was: That can’t possibly work. What about the electrochemical voltage series and the anode and cathode made of the same material? No, that’s really impossible. A simple experimental setup quickly shed light on the matter. Spoiler alert: It worked!

Test Setup

The rather simple experimental setup comprises three jam jars containing pencil leads wrapped in handkerchiefs. The electrolyte in the jars is a solution of Glauber’s salt, often used as a home remedy.

If you don’t have any Glauber’s salt in the house, you can find some online. Glauber’s salt is absolutely harmless compared with lithium. The only thing it sometimes causes, when ingested, is diarrhea, which is why it serves as a natural laxative in the materia medica.

To activate many ions to transport the charge, you need to dissolve as much salt as possible in the water. As Figure 1 shows, about 20g of Glauber’s salt can be dissolved in 100ml of water at a room temperature of 20°C. The jam jars each happen to hold about 100ml of water, so I dissolved 20g of Glauber’s salt in each.

The job of charging and discharging the battery is handled by a program. A relay module switches the connections to the power supply unit and consumer. To measure the current, I used an INA3221 module. In this experiment, I only need one of the three measuring inputs, but the module was already available in my tinkering box. The circuit diagram for the test setup is shown in Figure 2, and the complete setup is shown in Figure 3.

 Setup

For the project, I used the latest generation Raspberry Pi OS Lite. You can use RPI Imager to transfer the system to the memory card.

The INA3221 module is controlled over the I2C interface, which you need to enable by typing:

sudo raspi-config

In the interface, navigate to 5 Interfacing Options | P5 I2C and select YES. Next, install Java and some additional tools on the Raspberry Pi:

$ sudo apt update
$ sudo apt upgrade
$ sudo apt install default-jdk i2c-tools wiringpi

The experimental setup is now ready to test. To begin, you scan the I2C bus to find the devices (Listing 1). As expected, the INA3221 module resides on address 0x40.

Listing 1: Scanning the I2C Bus

$ i2cdetect -y 1
     0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: 40 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: – – – – – – – --

Use the commands

$ gpio mode 1 out
$ gpio mode 4 out
$ gpio write 1 0
$ gpio write 1 1
$ gpio write 4 0
$ gpio write 4 1

to make sure the relay is connected correctly. The first two lines set the GPIOs to output mode. The next two lines activate relay 1 for loading and switch it off again. The final two lines do the same for relay 2. The switching logic of the relay module is inverted, but this need not cause any confusion.

Measuring Program

To calculate the charge in this do-it-yourself battery, you need a small program that measures the current and time during charging and discharging. If the discharge current reaches 0mA, the battery is completely discharged.

When charging, things are a bit trickier, because you don’t know the end-of-charge voltage of the battery, so you simply charge for a certain time at 12V. In principle, you should charge with a voltage at which no gases escape from the battery. If your set-up starts to bubble, you need to reduce the charging voltage.

The program for the test setup is coded in Java. The i2c-detect and gpio tools control the GPIO and read out the measured values; the Java program starts these tools as sub-processes (Listing 2).

Listing 2: Controlling and Measuring

01 import java.util.Scanner;
02 public class SaltBattery {
03   public void setup() throws Exception {
04     new ProcessBuilder( "/usr/bin/gpio","mode","1","out" ).start();
05     new ProcessBuilder( "/usr/bin/gpio","mode","4","out" ).start();
06    loadOff();
07    unLoadOff();
08 }
09 public int switchBytes(int input){
10    input =((input & 0x00ff) << 0x08)|((input >> 0x08)&0x0ff);
11    int sign=1;
12    if (0<(input&0x8000)){
13      sign=-1;
14      input=((~input)&0xffff)+1;
15    }
16 return sign*input;
17 }
18 public void loadOn() throws Exception {
19    new ProcessBuilder( "/usr/bin/gpio","write","1","0" ).start();
20 }
21 public void loadOff() throws Exception {
22    new ProcessBuilder( "/usr/bin/gpio","write","1","1" ).start();
23 }
24 public void unLoadOn() throws Exception {
25    new ProcessBuilder( "/usr/bin/gpio","write","4","0" ).start();
26 }
27 public void unLoadOff() throws Exception {
28    new ProcessBuilder( "/usr/bin/gpio","write","4","1" ).start();
29 }
30   public double measureCurrent() throws Exception {
     Process p = new ProcessBuilder("i2cget","-y","1","0x40","0x03","w").start();
     Scanner s = new Scanner(p.getInputStream());
     return switchBytes(Integer.decode(s.next()))/20;
  }
  public double measureVoltage() throws Exception {
     Process p = new ProcessBuilder("i2cget","-y","1","0x40","0x04","w").start();
     Scanner s = new Scanner(p.getInputStream());
     return switchBytes(Integer.decode(s.next()))/1000;
  }
  public void go() {
     double sumCurrentUnload=0;
     double sumCurrentLoad=0;
     double current=0;
     int mesurementSteps=600;// Sec
     try {
       setup();
       System.out.println("Start battery charge");
       loadOn();
       for (int i=1; i<mesurementSteps ; i++) {
         current = measureCurrent();
         sumCurrentLoad +=current;
         Thread.sleep(1000);
       }
       loadOff();
       System.out.println("Start battery discharge");
       Thread.sleep(2000);
       unLoadOn();
       for (int i=1; i<mesurementSteps ; i++) {
         current = measureCurrent();
         sumCurrentUnload += current;
         System.out.println("Voltage:"+measureVoltage());
         if(current==0.0) break;
         Thread.sleep(1000);
       }
       unLoadOff();
    } catch (Exception e) {
         System.out.println(e);
       }
    System.out.println("Charge:"+sumCurrentLoad+" mAs");
    System.out.println("Discharge:"+sumCurrentUnload+" mAs");
  }// go
  public static void main(String[] args) {
    SaltBattery b=new SaltBattery();
    b.go();
  }// main
}// class

The switchBytes() method (line 9) plays a special role: It swaps the high and low bytes and interprets the most significant bit as a sign. If the number is negative, the program forms the two’s complement and sets the sign. These hacks are needed because the INA3221 module delivers the measured values in a machine language format that Java does not understand.

The measurement program is in the go() method (line 40). The first for loop (lines 49-53) measures the current once per second when the battery is charging, giving the amount of energy stored in the battery. The second for loop (lines 58-64) discharges the battery with a load resistor. When discharging, the program outputs the current voltage of the battery with each measurement. Here, too, it determines the amount of energy extracted.

At the end of the cycle, the script outputs the measured values. To find out a little about the characteristics of the battery, I discharged it with different load resistances (Table 1).

Not surprisingly, the battery built from household objects does not have particularly good efficiency. Much of the charge energy is lost, but it also clearly shows that the battery does store energy. Moreover, it looks like the capacity increases with the number of charging cycles; noticeably, the battery delivers slightly more power with less discharge.

This small test series shows that a saltwater battery works in principle. In the next section, I take a look at a commercially available saltwater battery.

Commercial Battery

Some manufacturers specialize in the production of these environmentally friendly energy storage systems. BlueSky Energy, for example, has a product – the Greenrock system – for both private and industrial use in its portfolio.

The storage systems are intended for stationary use only and are ideal for storing the energy generated by solar systems for personal consumption. As Figure 4 shows, a saltwater battery can certainly compete with the other electric storage systems on the market. In only two categories does it perform worse than a lithium-ion battery: energy density and C rating, which indicates how quickly the energy can be retrieved.

The energy density is not as good as that of lithium-ion batteries but is still as good as that of a lead-acid battery. Because of the lower energy density, the batteries are larger and heavier than lithium-ion batteries with the same capacity, but this is not really a problem when used indoors in a stationary environment.

With respect to the C rating, the saltwater battery turns out to be more of a marathon runner: It delivers a constant amount of energy over a long period of time, which is the application scenario in domestic use; however, it is not suitable for delivering high currents for short periods of time.

Saltwater batteries have several advantages over lithium-ion batteries. Apart from environmental friendliness and low fire hazard, the availability of resources plays a major role.

Discussions about electric vehicles have revealed that lithium mining causes considerable environmental damage. Recycling it is certainly a good idea, but it requires large amounts of energy and is expensive. Saltwater batteries fare far better in this respect; they cause virtually no environmental damage and are easy to recycle. The components of the saltwater battery exist on Earth in large quantities, whereas lithium does not.

A really serious issue that speaks against the use of lithium-ion batteries in buildings is their combustibility. You can find a number of YouTube videos that show the kind of fireworks that burning batteries of this type can cause. A saltwater battery, on the other hand, remains unfazed, even after prolonged exposure to heat.

Conclusions

The simple test setup in this article demonstrates that an energy storage device can be built with the simplest household objects. The Raspberry Pi helped keep the charging and discharging cycles the same and measured the charge. Although this scenario was merely an experimental setup that cannot be used in production, it works, and it can be modified for further experiments. One interesting question would be, for example, what level of self-discharge occurs.

Saltwater batteries have long been a mature and usable technology. They are well suited as energy storage for photovoltaic systems and, in contrast to lithium-ion batteries, they are unproblematic. If you are planning to install a photovoltaic system soon, check whether you really want to have lithium in your house or whether you prefer to rely on a safe and environmentally friendly battery technology.

Listings for this article.