Essendo interessato alla materia, mi diletto a dimensionare il mio “ipotetico” impianto fotovoltaico, off grid, utilizzando l’inseguitore solare astronomico, ma non amando particolarmente i fogli di calcolo e anche per fare un esercizio di stile (uso della logica nel calcolo di serie e parallelo) ho codificato questo script.

Può essere uno strumento interessante per appassionati e curiosi del mondo fotovoltaico off grid, che desiderano esplorare su come ottimizzare le configurazioni dei moduli solari e ricavare, di conseguenza, il regolatore di carica più adatto.

Ecco una guida dettagliata su come utilizzarlo.

Assicurati di avere Python installato sul tuo computer. Puoi utilizzare strumenti come Anaconda, PyCharm, Pyscripter o semplicemente un terminale con Python. È consigliabile avere una versione aggiornata di Python.

Prima di eseguire il codice, crea un file chiamato regolatori.json. Questo file conterrà le informazioni sui regolatori di carica. La struttura del file dovrebbe essere simile a questa:

[
    {
        "model": "Regolatore1",
        "voltage_max": 300,
        "current_max": 60
    },
    {
        "model": "Regolatore2",
        "voltage_max": 250,
        "current_max": 50
    }
]

Assicurati che il file JSON sia ben formato e salvato nella stessa cartella del tuo script Python.

Nel codice, troverai una sezione in cui sono definiti alcuni parametri chiave. Puoi personalizzare i seguenti valori:

num_modules: Numero di moduli fotovoltaici disponibili.
voc: Tensione a circuito aperto (in Volt) di ciascun modulo.
isc: Corrente a corto circuito (in Ampere) di ciascun modulo.
max_voltage: Tensione massima consentita per il sistema (in Volt).
max_current: Corrente massima consentita per il sistema (in Ampere).

Ecco un esempio di come modificare i parametri:

#
# Begin input parameters

num_modules = 24
voc = 45.59
isc = 13.96
max_voltage = 250
max_current = 50

# End input parameters

Una volta configurati i parametri e preparato il file JSON, sei pronto per eseguire lo script. Puoi farlo in vari modi:

• Da terminale: Spostati nella cartella dove si trova il tuo file Python e utilizza il comando:

  • python nome_del_file.py

• Da un IDE: Apri il file nel tuo ambiente di sviluppo preferito e avvia l’esecuzione del codice.

voc (Open Circuit Voltage): 45.59
isc (Short Circuit Current): 13.96
Voltaggio massimo: 250
Corrente massima: 50
Moduli in serie: 4
Numero di serie: 6
Corrente: 41.88
Migliore configurazione trovata:
Modello del regolatore: Regolatore2
Numero di moduli per serie: 4
Numero di serie realizzate: 6
Numeri di serie per parallelo: 3
Numeri di paralleli realizzati: 2
Tensione totale: 182.36 V
Corrente totale: 41.88 A
Regolatori necessari: 2

Puoi modificare i parametri di input per vedere come cambiano i risultati. Questo ti permetterà di comprendere meglio come diversi valori influenzano le configurazioni dei moduli fotovoltaici. Ogni volta che apporti modifiche ai valori, puoi rieseguire il codice ed ottenerne nuovi risultati.

Se incontri problemi, verifica quanto segue:

• Assicurati che il file regolatori.json sia nella stessa directory del tuo script.
• Controlla che il file JSON sia correttamente formattato e privo di errori di sintassi.
• Assicurati che i parametri di input siano valori numerici validi.

#
# L'uso dei questo software avviene a rischio dell'utente. Non si garantisce che il codice sia esente da errori o difetti,
# né si forniscono garanzie riguardo alla sua idoneità per scopi specifici.
#
# L'autore non è responsabile per eventuali danni, perdite o conseguenze derivanti dall'uso o dall'impossibilità di utilizzo del software.
#

import json

# Input parameters
num_modules = 24
voc = 45.59
isc = 13.96
max_voltage = 250
max_current = 50

print(f"voc (Open Circuit Voltage): {voc}")
print(f"isc (Short Circuit Current): {isc}")
print(f"Voltaggio massimo: {max_voltage}")
print(f"Corrente massima: {max_current}")

def load_regulators(filename):
    try:
        with open(filename, 'r') as file:
            return json.load(file)
    except FileNotFoundError:
        print(f"Errore: Il file '{filename}' non è stato trovato.")
        return []
    except json.JSONDecodeError:
        print(f"Errore: Il file '{filename}' non è un JSON valido.")
        return []

def search_dividers(n):
    if n < 1:
        raise ValueError("Il numero deve essere un intero positivo.")
    return [i for i in range(1, n + 1) if n % i == 0]

def calculate_series_config(num_modules, voc, max_voltage):
    dividers = search_dividers(num_modules)

    # Prioritize higher number of modules in series
    for count in reversed(dividers):
        voltage = voc * count
        if voltage < max_voltage:
            modules_per_series_count = count
            series_count = num_modules // modules_per_series_count
            series_max_voltage = voc * modules_per_series_count
            return modules_per_series_count, series_count, series_max_voltage
    return None, None, None

def calculate_parallel_config(num_modules, isc, series_count, max_current):
    dividers = search_dividers(series_count)

    # Track the best configuration
    best_parallel_count = None
    best_series_per_parallel_count = None
    best_total_current = None

    for count in dividers:
        current = isc * count
        if current <= max_current:
            # Calculate how many strings can be connected in parallel
            series_per_parallel_count = count
            parallels_count = num_modules // (series_per_parallel_count * (num_modules // series_count))

            # Store the best configuration if it results in fewer regulators
            if best_parallel_count is None or parallels_count < best_parallel_count:
                best_parallel_count = parallels_count
                best_series_per_parallel_count = series_per_parallel_count
                best_total_current = current

    return best_series_per_parallel_count, best_parallel_count, best_total_current


def search_best_config(par_count, voltage_per_series, current_per_parallel, regulators):
    for regulator in regulators:
        if (voltage_per_series <= regulator['voltage_max']) and (current_per_parallel <= regulator['current_max']):
            return {
                'regulator': regulator['model'],
                'parallel_count': par_count,
                'total_voltage': voltage_per_series,
                'total_current': current_per_parallel,
                'total_strings': par_count
            }
    return None

def print_best_configuration(best_config, best_regulator):
    if best_config and best_regulator:
        print("Migliore configurazione trovata:")
        print(f"Modello del regolatore: {best_regulator['regulator']}")
        print(f"Numero di moduli per serie: {best_config['modules_per_series_count']}")
        print(f"Numero di serie realizzate: {best_config['series_count']}")
        print(f"Numeri di serie per parallelo: {best_config['series_per_parallel_count']}")
        print(f"Numeri di paralleli realizzati: {best_config['parallels_count']}")
        print(f"Tensione totale: {best_config['total_voltage']:.2f} V")
        print(f"Corrente totale: {best_config['total_current']:.2f} A")
        print(f"Regolatori necessari: {best_config['parallel_count']}")
    else:
        print("Nessuna configurazione valida trovata.")

def calculate_combinations(num_modules, voc, isc, max_voltage, max_current, regulators):
    modules_per_series_count, series_count, series_max_voltage = calculate_series_config(num_modules, voc, max_voltage)

    if modules_per_series_count is None:
        print("Nessuna configurazione valida per le serie.")
        return

    print(f"Moduli in serie: {modules_per_series_count}")
    print(f"Numero di serie: {series_count}")

    series_per_parallel_count, parallels_count, total_current = calculate_parallel_config(num_modules, isc, series_count, max_current)

    if series_per_parallel_count is None:
        print("Nessuna configurazione valida per i paralleli.")
        return

    print(f"Corrente: {total_current:.2f}")

    best_config = {
        'modules_per_series_count': modules_per_series_count,
        'series_count': series_count,
        'series_per_parallel_count': series_per_parallel_count,
        'parallels_count': parallels_count,
        'total_voltage': series_max_voltage,
        'total_current': total_current,
        'parallel_count': parallels_count  # Ensure this is included
    }

    best_regulator = search_best_config(parallels_count, series_max_voltage, total_current, regulators)

    print_best_configuration(best_config, best_regulator)


def main():
    regulators = load_regulators('regolatori.json')

    if not regulators:
        print("Nessun regolatore caricato. Terminazione del programma.")
        return

    calculate_combinations(num_modules, voc, isc, max_voltage, max_current, regulators)

if __name__ == '__main__':
    main()

Lascio anche il mio file relativo ai regolatori di carica per fotovoltaico off grid, per coloro interessati a marchio Victron.

[
    {
        "model": "SmartSolar MPPT 75/10 o BlueSolar MPPT 75/10",
        "voltage_max": 75,
        "current_max": 10
    },
    {
        "model": "SmartSolar MPPT 75/15 o BlueSolar MPPT 75/15",
        "voltage_max": 75,
        "current_max": 15
    },
    {
        "model": "SmartSolar MPPT 100/15 o BlueSolar MPPT 100/15",
        "voltage_max": 100,
        "current_max": 15
    },
    {
        "model": "SmartSolar MPPT 100/20 o BlueSolar MPPT 100/20",
        "voltage_max": 100,
        "current_max": 20
    },
    {
        "model": "SmartSolar MPPT 100/30",
        "voltage_max": 100,
        "current_max": 30
    },
    {
        "model": "SmartSolar MPPT 100/50",
        "voltage_max": 100,
        "current_max": 50
    },
    {
        "model": "SmartSolar MPPT 150/35",
        "voltage_max": 150,
        "current_max": 35
    },
    {
        "model": "SmartSolar MPPT 150/45",
        "voltage_max": 150,
        "current_max": 45
    },
    {
        "model": "SmartSolar MPPT 150/60 fino a 250/70",
        "voltage_max": 150,
        "current_max": 60
    },
    {
        "model": "SmartSolar MPPT 150/70 fino a 250/100 VE.Can",
        "voltage_max": 150,
        "current_max": 70
    },
    {
        "model": "SmartSolar MPPT 250/60",
        "voltage_max": 250,
        "current_max": 60
    },
    {
        "model": "SmartSolar MPPT 150/60 fino a 250/70",
        "voltage_max": 250,
        "current_max": 70
    },
    {
        "model": "SmartSolar MPPT 250/100",
        "voltage_max": 250,
        "current_max": 100
    },
    {
        "model": "MPPT RS SmartSolar 450/100",
        "voltage_max": 450,
        "current_max": 100
    },
    {
        "model": "MPPT RS SmartSolar 450/200",
        "voltage_max": 450,
        "current_max": 200
    }
]

Il codice software pubblicato è fornito esclusivamente a scopo didattico e viene messo a disposizione “così com’è”. L’uso del software avviene a rischio dell’utente. Non si garantisce che il codice sia esente da errori o difetti, né si forniscono garanzie riguardo alla sua idoneità per scopi specifici.

L’autore non è responsabile per eventuali danni, perdite o conseguenze derivanti dall’uso o dall’impossibilità di utilizzo del software.

Data: La data di pubblicazione del presente articolo.
Pubblicato su: blog.nicolamontemurro.com

Questo codice Python offre un modo interessante per esplorare le varie configurazioni dei moduli fotovoltaici e trovare le soluzioni più adatte, ma è da intendersi ad uso didattico; Non può in alcun modo, sostituire il computo effettuato da un professionista.