Obviously, it's hard to compare exact weather conditions - lower temperature makes for more efficient generation - but I've picked a date in April where both sets of panels seemed to have an unblemished view of the sky.

This is the South-facing panels in Oxford generating 24.28kWh.

And here's the E/W split in London generating 18.59kWh.

London - despite the disadvantageous placement of the panels - generated 75% of the electricity that Oxford did! That's much more impressive than I was expecting. True, the panels have 25% more potential, and are slightly further South, but I was expecting the split to make things much worse.

I've written some code to graph how the different sides of the roof perform. This means I can see how East compares to West. Naïvely, I assumed that the panels not directly illuminated by sunlight would be basically useless. But nothing could be further from the truth!

Here's the split of the above graph.

Wow! Both East and West generated about the same amount of power - 9kWh.

Given the average UK household uses ~10kWh per day, I could have completely offset my energy use with half the panels!

There are some caveats. Spring is perfect solar weather - long days, cool temperatures, and little tree coverage. Cloud coverage can ruin the generation.

Edent's Solar Panels

@Edent_Solar
Automated

East facing solar panels 🆚 West facing solar panels. London, UK. pic.x.com/TB0afpTUX9

---

If you're thinking about getting solar panels, but are worried about your roof's layout - I hope this provides some useful information.

You can follow my solar panels on Twitter.

SolarWeb has an (optional) guest mode. You can view the panels' performance if you know the secret URl. It looks something like this:

https://www.solarweb.com/Home/GuestLogOn?pvSystemid=123-456-789

Visiting that URl sets some cookies and then redirects you to something like this:

https://www.solarweb.com/PvSystems/PvSystem?pvSystemId=abc-def-hij

And the live performance data is at: https://www.solarweb.com/ActualData/GetCompareDataForPvSystem?pvSystemId=abc-def-hij

In order to make a request to the data URl, you need the cookies from the first URl. Here's some horrible PHP which will do just that.

<?php

$ch = curl_init();
//  Get the loging URl
curl_setopt($ch, CURLOPT_URL, "https://www.solarweb.com/Home/GuestLogOn?pvSystemid=123-456-789");
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true); //  It redirects
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

//  Store and use cookies
curl_setopt($ch, CURLOPT_COOKIEJAR,  '/tmp/cookies.txt');
curl_setopt($ch, CURLOPT_COOKIEFILE, '/tmp/cookies.txt');

//  Get the page
curl_exec($ch);

//  Find redirect URL
$redirect_url    = curl_getinfo($ch)["url"];
//  It is in the form https://www.solarweb.com/PvSystems/PvSystem?pvSystemId=abc-def-hij
//  Get the System ID
$system_id_query = parse_url($redirect_url, PHP_URL_QUERY);
parse_str($system_id_query, $params);
$system_id = $params["pvSystemId"];

//  Finish up this request
curl_close($ch);

//  2nd request
$ch = curl_init();
//  URl of the data
curl_setopt($ch, CURLOPT_URL, "https://www.solarweb.com/ActualData/GetCompareDataForPvSystem?pvSystemId={$system_id}");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
//  Use cookies
curl_setopt($ch, CURLOPT_COOKIEJAR,  '/tmp/cookies.txt');
curl_setopt($ch, CURLOPT_COOKIEFILE, '/tmp/cookies.txt');
$output = curl_exec($ch);

//  Output JSON
// header("Content-Type: application/json");
echo $output;
//  Clean up
curl_close($ch);

And, hey presto, out pops a scrap of JSON:

{
   "Datasources":"n/a",
   "IsOnline":true,
   "P_PV":402.0
}

1. Installation
2. Inverter
3. API & Code

My solar panels have an API! It tells me the total amount of power they've generated each day. But there's a small problem... I have panels on the East and West sides of my roof. My solar inverter has two MPPT "String" inputs. That is, East and West supply power separately. Luckily, there's an API for that!

Thanks to "Grannos" on the PVOutput forum for their excellent open source code which helped get me started.

Edent's Solar Panels

@Edent_Solar
Automated

East facing solar panels 🆚 West facing solar panels. London, UK. pic.x.com/p2Bi1X15uD

---

API Call

This is slightly hidden in the official API documentation. You have to query the historic data. If you query today's date, you can get sort-of real time data.

This is the call - replace the IP address with your own:

http://192.168.0.123/solar_api/v1/GetArchiveData.cgi?
   Scope=System&
   StartDate=2020-03-25&
     EndDate=2020-03-25&
   Channel=Voltage_DC_String_1&
   Channel=Current_DC_String_1&
   Channel=Voltage_DC_String_2&
   Channel=Current_DC_String_2

Data Structure

This is a truncated view of the data:

{
    "Body": {
        "Data": {
            "inverter/1": {
                "Data": {
                    "Current_DC_String_1": {
                        "Unit": "A",
                        "Values": {
                            ...
                            "57000": 3.3999999999999999,
                            "57300": 2.8300000000000001,
                            "57600": 2.6400000000000001,
                            ...
                        },
                    },
                    "Current_DC_String_2": {
                        "Unit": "A",
                        "Values": {
                            ...
                            "57000": 0.42999999999999999,
                            "57300": 0.41999999999999998,
                            "57600": 0.41000000000000003,
                            ...
                        },
                    },
                    "Voltage_DC_String_1": {
                        "Unit": "V",
                        "Values": {
                            ...
                            "57000": 215.5,
                            "57300": 233.40000000000001,
                            "57600": 228.90000000000001,
                            ...
                        },
                    },
                    "Voltage_DC_String_2": {
                        "Unit": "V",
                        "Values": {
                            ...
                            "57000": 271.10000000000002,
                            "57300": 264.19999999999999,
                            "57600": 260.5,
                            ...
                        },
                    }
                },

The timestamps are seconds-since-midnight. They're sampled every 5 minutes (300 seconds) - so 57000 is 15:50.

I've got the power!

To get the power, multiply the Amps by the Voltage. That gets you the Watts. SCIENCE!

I'm sure there is a better way to do this, and I'd be grateful for any pointers.

Get today's data from the inverter

today = now.strftime("%Y-%m-%d")

# Get today's data from the inverter
API_url = "http://" + fronius_IP_address + "/solar_api/v1/GetArchiveData.cgi?Scope=System&StartDate=" + today + "&EndDate=" + today + "&Channel=Voltage_DC_String_1&Channel=Current_DC_String_1&Channel=Voltage_DC_String_2&Channel=Current_DC_String_2"

response = requests.get(url=API_url)
data = json.loads(response.text)

Add it into a structured and ordered format

string1_current = data["Body"]["Data"]["inverter/1"]["Data"]["Current_DC_String_1"]["Values"]
#   Keys to ints, Values to floats
string1_current = {int(k):float(v) for k,v in string1_current.items()}
string1_current = sorted(string1_current.items())

string2_current = data["Body"]["Data"]["inverter/1"]["Data"]["Current_DC_String_2"]["Values"]
#   Keys to ints, Values to floats
string2_current = {int(k):float(v) for k,v in string2_current.items()}
string2_current = sorted(string2_current.items())

string1_voltage = data["Body"]["Data"]["inverter/1"]["Data"]["Voltage_DC_String_1"]["Values"]
#   Keys to ints, Values to floats
string1_voltage = {int(k):float(v) for k,v in string1_voltage.items()}
string1_voltage = sorted(string1_voltage.items())

string2_voltage = data["Body"]["Data"]["inverter/1"]["Data"]["Voltage_DC_String_2"]["Values"]
#   Keys to ints, Values to floats
string2_voltage = {int(k):float(v) for k,v in string2_voltage.items()}
string2_voltage = sorted(string2_voltage.items())

Calculating the power

timestamp_list = []
string1_watts  = []
string2_watts  = []

for current, voltage in zip(string1_current, string1_voltage):
    timestamp_list.append(str(datetime.timedelta(seconds=current[0]))[:-3]) #   Remove the seconds
    string1_watts.append(int(current[1] * voltage[1]))

for current, voltage in zip(string2_current, string2_voltage):
    string2_watts.append(int(current[1] * voltage[1]))

#   Remove the first 4:30 hours (54 * 5 minutes)
#   Earliest sunrise about 04:40
#   Latest sunset about 2130
timestamp_list = timestamp_list[54:]
string1_watts  = string1_watts[54:]
string2_watts  = string2_watts[54:]

#   Total Power Generation
#   Bit sketchy. Only samples ever 5 minutes.
string1_kWh = str(round(sum(string1_watts) * 5 / 60 / 1000, 2))
string2_kWh = str(round(sum(string2_watts) * 5 / 60 / 1000, 2))

Write the CSV

This is my least favourite part of the code. It zips together the timestamps and the wattage from the first String. Then zips it with the 2nd String.

with open(csv_file, 'w', newline='') as csvfile:
    writer = csv.writer(csvfile)
    for a, b in zip(zip(timestamp_list,string1_watts),string2_watts):
        t  = str(a[0])
        w1 = str(a[1])
        w2 = str(b)
        writer.writerow([t,w1,w2])

Source Code

All available on my GitHub

Output

1. Installation
2. Inverter

Fronius provide a comprehensive API guide - I wish more companies did this. There are lots of unofficial libraries in a variety of different languages. I've written this code in Python3.

This is a general tidy-up of the code I wrote several years ago.

Here's how it works....

• Every minute, the script runs from crontab.
• If it is after sunrise and before sunset, it takes a reading and writes it to today's CSV file.
• If it is after sunset, draw a graph, save it, Tweet it.
  • Only do this once.

This is in Python3 so should run on a Raspberry Pi - or any other computer.

If you are running this code on the same network as your Fronius, there is no security. The API lets you read data without a password.

You can get the latest code on GitHub.

Output

Edent's Solar Panels

@Edent_Solar
Automated

Today I generated 16.19kWh of solar electricity. pic.x.com/puH8Pwfbev

---

We chose a Fronius Primo inverter - they're a reliable brand which we used in our previous build. I've been impressed that every few months my inverter's software was upgraded. Not bad for a 6 year old bit of kit.

And, most importantly for my purposes, it has an API!

Internet Connection

The Primo has two Ethernet jacks and built in WiFi. Obviously Ethernet provides a more stable and secure connection - but running a cable to the loft isn't always easy. The WiFi only supports 2.4GHz - but that's fine. It has better range than 5GHz, and it's not like this thing is streaming gigabytes of data.

When you set up the inverter, it can broadcast a WiFi access point. You can connect to this to get it set up and then provide your normal WiFi details.

Rather disappointingly, the password is hard-coded as 12345678. The same code I use on my luggage.

What's the 2nd jack for? It acts as a hub, so you can hook up several inverters to the network.

Display Screen

There's a little display screen with 4 control buttons:

It's basic, but does the job. Lets you configure the inverter, set the time, monitor the status.

Ports

If you don't want to hook your electricity up to the Internet (what could possibly go wrong?!) there's an internal USB port. This can be used for updating the firmware. Or as a datalogger.

There are a couple of other connectors. A serial port (RS485) for "Modbus RTU SunSpec or meter connection".

You also get 6 inputs and 4 digital inputs/outputs. These are the interface to "ripple control receiver". I have no idea what they do. Perhaps I'll shove some wires in to them and hook up a Raspberry Pi?

Web Interface

The web interface is pretty swishy. It also allows you to set up a "guest" URL for read only access. Handy if you want your installer to be able to monitor your system.

There's also an app - but, like most apps, it's a bit crap.

There are separate usernames and passwords for administrator and user accounts. This means that only authorised people can change the settings. Good!

The read-only API is unauthenticated. So anyone on your network can see real-time power generation data. That's probably fine - but it would be nice if that could optionally be protected.

Firmware

Mine came with the latest firmware. The web interface will alert you when there's an update.

Amazingly, Fronius provides detailed changelogs with each release.

Web Push

The inverter can regularly push data to an external system. Either via FTP or HTTP POST in a variety of different formats.

There's a handy guide on PVOutput if you want to use their services for monitoring.

API

Finally - there's a JSON API! That's what we're going to explore in tomorrow's blog post.