camelot-forum.co.uk

Code: Select all

const maxPowerHouseIn=230*60

function log(text) {
    // text = text
    // node.warn(text)
}

function efficiencyAt(power) {
    power = power / 1000
    const a = (power * .1) / 6    
    const eff = 0.9366 - a   //.966 was the original number
    return eff
}

class ChargeState {
    static HoldCharge = new ChargeState('HoldCharge');
    static UseBattery = new ChargeState('UseBattery');
    static EmptyBattey = new ChargeState('EmptyBattery')
    static ExpensivePeriod = new ChargeState('ExpensivePeriod')
    static ChargeBattery = new ChargeState('ChargeBattery');
    constructor(name) {
        this.name = name;
    }
    toString() {
        return `Color.${this.name}`;
    }
}

var debug={};
var msg2={};   
var msg3={};

const battery=global.get("state_Battery");
const SOC = msg.payload["BatterySOC"];
const batteryPower = msg.payload["BatteryPower"];
const setpoint=msg.payload["ESS_Setpoint"];
const mppt=msg.payload["PV_MPPT"] || 0;

// const PV_Power = msg.payload["PV_SE"] + mppt;
const PV_Power = flow.get("PV_SE") + mppt;
const consumption = msg.payload["consumption"];
var currentSchedule = global.get("CurrentSchedule");
const SOCInfo=flow.get("SOCInfo")
var maxInverterPower = 0;
var newSetpoint = 20;
var nodeWarn="green";

debug["Default"]={"battery":battery,"SOC":SOC,"setpoint":setpoint};

function getChargeStateInCheapPeriod() {
    var state =0
    
    var desiredSOC
    if (currentSchedule.override)
        desiredSOC=currentSchedule.SOC
    else 
        desiredSOC = SOCInfo.nextSOC // THis is enough to get through the period

    const notBelowSOC = SOCInfo.notBelowDuringCharge

    log("SOC:"+SOC+"notbel"+notBelowSOC+"desired"+desiredSOC)
    // if(SOCInfo.maxSOCToday==100)
    // {
    //     state = ChargeState.EmptyBattey
    // }else
     if ((SOC > notBelowSOC || SOCInfo.maxSOCToday==100) && SOC >desiredSOC && SOCInfo.correction==0)
        state = ChargeState.UseBattery
    else if (SOC >= desiredSOC)
        state = ChargeState.HoldCharge
    else
        state = ChargeState.ChargeBattery


    return state
}

//New charge state c
var state = ChargeState.ChargeBattery

if (currentSchedule.cheapPeriod){
    state=getChargeStateInCheapPeriod();
} else {
    state= ChargeState.ExpensivePeriod
}

// This will aim to hit the SOC at the end of the period
function getChargeRateToMeetSOC(desiredSOC){
    // Do the math to find the new charge rate
    var now = new Date();
    var hoursNow = now.getHours();
    var minutesNow = now.getMinutes();

    var startTimeStr = currentSchedule["start"];
    var startT = startTimeStr.split(":");

    var startHour = startT[0];
    var startMinute = startT[1];

    var startTime = new Date();
    startTime.setHours(startHour)
    startTime.setMinutes(startMinute);

    var timeR = currentSchedule["length"].split(":");
    var diff = timeR[0] * 60 + timeR[1] * 1;

    var endTime = new Date(startTime.valueOf() + diff * 60000);

    //Correct for times running over midnight
    if (endTime.valueOf() < now.valueOf()) {
        var etv = endTime.valueOf() - 24 * 60 * 60 * 1000;
        endTime = new Date(etv);
    }

    var remainingTime = (endTime.valueOf() - now.valueOf()) / 60000;
    var remainingSOC = desiredSOC - SOC;
    var powerRemaining = remainingSOC / 100 * 4800 * 8;
    var powerPerHour = Math.round(powerRemaining / remainingTime * 60);
    // How much needs to go into the battery.
    return powerPerHour
}

// Meets the battery charge discharge based on grid only.
function setPointToMeetBattery(chargeRate){
// node.warn(PV_Power)
    if (chargeRate>0) {
        chargeRate = chargeRate / efficiencyAt(chargeRate)
    } else {
        chargeRate = chargeRate / efficiencyAt(chargeRate)
    }

    // If this isn't added then the battery will discharge at about 100W
    // This currently causes oscillations.. needs damping
    if (chargeRate==0){
        const battery = global.get("state_Battery")
        chargeRate=-battery.power*.7
    }

    // new set point
    // Problem is the mppt... In the morning it is the only power and causes issues
    const setPoint= consumption - PV_Power + chargeRate;
    return setPoint
}

function clampValue(value,min,max){
   
    if (value <min)
        value = min
    else if (value>max)
        value = max

    return value
}

var powerPerHour=0
var chargerOn=false

function isSunny(){
    return msg.payload.PV_State != 0
}

log("state"+state.name)
//If we are not in a charge schedule then return 20 which will be the default state to use the battery
switch (state.name) {
    case ChargeState.ExpensivePeriod.name:
    {
        log ("expensive charge: "+0)
        if (isSunny())
            chargerOn = true  // This is required if pv is greater than load
         else 
            chargerOn= false // It is dark so we won't be charging
         
        maxInverterPower = -1
        newSetpoint = 0
        log("max inverter"+ maxInverterPower)
        break
    }
    case ChargeState.EmptyBattey.name:
    {
        maxInverterPower=10000
        // var chargeRate= getChargeRateToMeetSOC(SOCInfo.nextSOC)
        newSetpoint=setPointToMeetBattery(-maxInverterPower)
        chargerOn=false
        break
    }
    case ChargeState.UseBattery.name:
    {
            log("usebattery"+ 0)
        if (isSunny())
        {
            maxInverterPower = -1 // Without this the load won't be powered by mppt
            chargerOn = true // The battery won't be powered by excess sunlight without this.
        }else
        {
            var chargeRate = getChargeRateToMeetSOC(SOCInfo.notBelowDuringCharge)
            maxInverterPower =-1// clampValue(chargeRate, 1000, 9000) // Limit lower level to 1000 since it gets very inefficient below this level.
            chargerOn=false
        }
       
        newSetpoint = 0
        break
    }
    case ChargeState.HoldCharge.name:
    {
        chargerOn = msg.payload.PV_State > 0  // Charge if there is PV
       
       // We have a minimum value of 0 so that we are not exporting. This doesn't work. 
       if(msg.payload.PV_State!=0 && mppt>500)  //if day
            maxInverterPower=-1  // Do this or we won't export any extra power.
        else
            maxInverterPower=0 // Night time freeze the inverter
        
        if (SOC>98)
        newSetpoint=0
        else {
            //was clamped to 9000 for inverter. this is worng
            newSetpoint=clampValue(setPointToMeetBattery(0),0,maxPowerHouseIn) 
        }
        break
    }
    case ChargeState.ChargeBattery.name:
    {
        chargerOn=true
        maxInverterPower = -1 // depends on sunshine and loads

        var nextSOC=SOCInfo.nextSOC

        if (currentSchedule.override){
            nextSOC=currentSchedule.SOC
            nodeWarn="blue"
        }

        var chargeRate = getChargeRateToMeetSOC(nextSOC)
        //set the minimum level to 1000 if no solar.
        var minimumChargeRate
        if (!isSunny()){
            minimumChargeRate=1000
        } else {
            minimumChargeRate=0
        }
        chargeRate = clampValue(chargeRate, minimumChargeRate, 7300) // Limit lower level to 1000 since it gets very inefficient below this level.
        powerPerHour = chargeRate // set this value for the node status
        chargeRate=chargeRate
        newSetpoint=clampValue(setPointToMeetBattery(chargeRate),0,12000) // Be nice to the house input and make sure we don't export

        break
    }
}

const chargeZappie = false
if (chargeZappie) {
        /*
        grid = load-solar-battery
        battery=load-solar-grid

        -200=load-solar-4000
        load-solar=-4000
        */
        // var sum = load-solar
        const flag=context.get("flag")
        context.set("flag",!flag)
        var psp=context.get("lastpoint")

        // if (flag){
            const batteryCorrection=4400-batteryPower
            log("battery" + batteryPower+ " correction:"+batteryCorrection)
            newSetpoint= batteryCorrection*.5
        // } else {
            // newSetpoint=psp
        // }

        var dif=newSetpoint-psp
        log("nsp:" + newSetpoint + " dif:" + dif)
        newSetpoint=psp+.1*dif

        if(newSetpoint>0)
            newSetpoint=0


        context.set("lastpoint",newSetpoint)
}
newSetpoint = Math.round(newSetpoint);
msg.debug = debug;
msg.payload = newSetpoint;
msg2.payload = currentSchedule["SOC"];

/*Value types

0 - Charge allowed
1 - Charge disabled
*/
log("chargeron:"+chargerOn)
msg2.payload = chargerOn ? 0:1
// msg2.payload=0
msg3.payload = maxInverterPower
log("max inverter"+maxInverterPower)
const text = state.name + " SOC:" + SOCInfo.nextSOC +  "PowerRq: "+powerPerHour+"W,Set: "+newSetpoint
node.status({fill:nodeWarn,shape:"dot",text: text});


// set point, min soc, inverter level.
return [msg,msg2,msg3]