followme_e-tron/Nasal/electrical.nas

#//Followme EV electrical system by Sidi Liang
#//Contact: sidi.liang@gmail.com

#//Notes: switch should be changed to a (very very) large resistant

io.include("library.nas");

var electricalDebug = Debugger.new("Electrical");
electricalDebug.setDebugLevel(0);

var kWh2kWs = func(kWh){
    return kWh * 3600;
}
var kWs2kWh = func(kWs){
    return kWs / 3600;
}

var Series = {
    #//Class for any series connection
    new: func() {
        return { parents:[Series] };
    },
    units: [],
    addUnit: func(unit){
        append(me.units, unit);
    },
    isSwitch: func(){
        return 0;
    },

    totalResistance: func(){
        var total = 0;
        foreach(elem; me.units){
            total += elem.resistance;
        }
        return total;
    },

    totalActivePower: func(){
        var total = 0;
        foreach(elem; me.units){
            total += elem.activePower;
            total += elem.activePower_kW * 1000;
        }
        return total;
    },

    totalPower: func(){
        var total = 0;
        foreach(elem; me.units){
            total += elem.power();
        }
        return total;
    },


    voltage: 0, #//Total Voltage Input, Volt
    current: 0, #//current, Ampere
    totalCounterElectromotiveForce: 0,#//Total counterElectromotiveForce, calculated from v=Power output / I, after the current is calculated

    updateCurrent: func(){

        #//Calculated by solving the equation UI = I^2*R + Power output
        var R = me.totalResistance();
        var U = me.voltage;
        var Pout = me.totalActivePower();
        if(U == 0){
            me.current = 0;
            return 0;#//No voltage, no current.
        }

        #//print("U ",U," R ",R," Pout ",Pout);

        var deltaSquared = U*U - 4*R*Pout;

        if(deltaSquared < 0){
            electricalDebug.debugPrint("Electrical: Floting point error when calculating current! skipping", 1);
            deltaSquared = 0;
        }

        var delta = math.sqrt(deltaSquared);

        #//used to be minus, but adding it seems to be correct
        var result = (U+delta)/(2*R); #//Ampere
        me.current = result;
        me.totalCounterElectromotiveForce = Pout / result; #//Calculate the totalCounterElectromotiveForce

        return result;
    },

    calculateSeriesVoltage: func(){
        me.updateCurrent();
        cElectromotiveForce = me.totalCounterElectromotiveForce;

        #totalTmp = 0;
        #foreach(elem; me.units){
        #    totalTmp += elem.current * elem.current * elem.resistance + elem.activePower + elem.activePower_kW * 1000;
        #}

        foreach(elem; me.units){
            if(me.current){
                elem.voltage = me.current * elem.resistance + (elem.activePower + elem.activePower_kW * 1000) / me.current;
            }else{
                elem.voltage = 0;
            }

            #var factor = (elem.current * elem.current * elem.resistance + elem.activePower + elem.activePower_kW * 1000)/totalTmp;
            #elem.voltage = me.voltage * factor;
            electricalDebug.debugPrint(elem.applianceName ~ " volt" ~ elem.voltage, 3);
        }
        electricalDebug.debugPrint("____________________________SeriesVoltage calculated____________________________", 3);
    },

    calculateApplianceCurrent: func(){
        foreach(elem; me.units){
            elem.current = me.current;
        }
    },
};

var Circuit = {
    #//Class for any circuit
    #//Currently must be initalized with a source
    #//Currently only support one voltage source in a circuit
    new: func(vSource) {
        var new_circuit = { parents:[Circuit] };
        new_circuit.addNewSeriesWithUnitToParallel(vSource);
        return new_circuit;
    },


    parallelConnection: [],

    newSeriesWithUnits: func(addedUnits...){
        var newSeries = Series.new();
        foreach(elem; addedUnits){
            newSeries.addUnit(elem);
        }
        return newSeries;
    },


    addUnitToSeries: func(seriesNum, unit){
        me.parallelConnection[seriesNum].addUnit(unit);
    },

    addParallel: func(units){
      append(me.parallelConnection, units);
    },

    addNewSeriesWithUnitToParallel: func(units){
        var new_series = me.newSeriesWithUnits(units);
        me.addParallel(new_series);
    },


    current: 0, #//Ampere
    voltage: func(){ #//Terminal voltage
        var v = me.parallelConnection[0].units[0].electromotiveForce - me.calculateTotalParallelCurrent()*me.parallelConnection[0].units[0].resistance;
        return v
    }, #//Volt

    calculateParallelVoltage: func(){
        #//var setVoltage = me.voltage();
        var setVoltage = me.parallelConnection[0].units[0].electromotiveForce; #//2021/8/9 note: view it as ideal voltage source for now
        foreach(elem; me.parallelConnection){
            elem.voltage = setVoltage;
        }
    }, #//Volt

    calculateSeriesCurrentAndVoltage: func(){
        foreach(elem; me.parallelConnection){
            elem.updateCurrent();
            elem.calculateSeriesVoltage();
        }
    }, #//Volt

    calculateTotalParallelCurrent: func(){
        var total = 0;
        foreach(elem; me.parallelConnection){
            total += elem.current;
        }
        me.current = total;
        return total;
    }, #//Ampere

    calculateTotalPower: func(){
      var total = 0;
      foreach(elem; me.parallelConnection){
          total += elem.totalPower();
      }
      return total;
    },

    updateInterval: 0.1, #//Seconds between each update

    loopCount: 0,

    update: func(){
        electricalDebug.debugPrint("Loop Count: "~me.loopCount, 1);

        me.calculateParallelVoltage();
        electricalDebug.debugPrint("Parallel Voltage Calculated", 2);

        electricalDebug.debugPrint("Power: "~me.calculateTotalPower(), 1);

        me.calculateSeriesCurrentAndVoltage();
        electricalDebug.debugPrint("Series Current and Voltage Calculated", 2);

        foreach(elem; me.parallelConnection){
            elem.calculateApplianceCurrent();
        }
        electricalDebug.debugPrint("Applicance Current Calculated", 2);

        me.calculateTotalParallelCurrent();
        electricalDebug.debugPrint("Parallel Current Calculated", 2);

        foreach(elem; me.parallelConnection){
            foreach(unit; elem.units){
                if(unit.isVoltageSource()) unit.voltageSourceUpdate(me.calculateTotalPower(), me.updateInterval); #//Update the voltage source. Pass in negetive power in case of charging
            }
        }
        electricalDebug.debugPrint("Power Calculated", 2);

        props.getNode("/systems/electrical/e-tron/battery-kWh", 1).setValue(me.parallelConnection[0].units[0].getRemainingInkWh());
        props.getNode("/systems/electrical/e-tron/battery-remaining-percent", 1).setValue(me.parallelConnection[0].units[0].getRemainingPercentage());
        props.getNode("/systems/electrical/e-tron/battery-remaining-percent-float", 1).setValue(me.parallelConnection[0].units[0].getRemainingPercentageFloat());

        vehicleInformation.systems.electrical.getMainBatteryRemainingPercentage = me.parallelConnection[0].units[0].getRemainingPercentage();
        vehicleInformation.systems.electrical.getMainBatteryRemainingPercentageFloat = me.parallelConnection[0].units[0].getRemainingPercentageFloat();

        electricalDebug.debugPrint("current: "~me.current, 1);
        electricalDebug.debugPrint("terminal voltage: "~me.voltage(), 1);
        electricalDebug.debugPrint("Main Battery Remaining: "~me.parallelConnection[0].units[0].remaining, 1);
        #//if(me.debugMode)
        #//print("Secondery Battery Remaining: "~me.parallelConnection[0].units[0].remaining);

        me.loopCount += 1;
    },


};

var Appliance = {
    #//Class for any electrical appliance
    new: func() {
        return { parents:[Appliance] };
    },

    isVoltageSource: func(){
        return 0;
    },

    ratedPower: 0, #//rate power , Watt, 0 if isResistor

    isSwitch: func(){
        return 0;
    },

    resistance: 0, #//electric resistance, Ωμέγα
    resistivity: 0,#//Ω·m
    voltage: 0, #//electric voltage, Volt
    current: 0, #//electric current, Ampere
    activePower: 0, #//Output Power, Watt
    activePower_kW: 0, #//Output Power, kWatt, independence of activePower
    heatingPower: func(){
        return me.current * me.current * me.resistance;
    },#//heating Power
    power: func(){
        electricalDebug.debugPrint("Applicance " ~ me.applianceName ~" power: " ~ (me.activePower + me.activePower_kW*1000 + me.heatingPower()), 4);
        return me.activePower + me.activePower_kW*1000 + me.heatingPower();
    },
    counterElectromotiveForce: func(){
        return (me.activePower + me.activePower_kW*1000)/me.current; #//Counter Electromotive Force calculated by output power divided by current
    },

    isResistor: 0,

    applianceName: "Appliance",
    applianceDescription: "This is a electric appliance",

    setName: func(text){
        me.applianceName = text;
    },
    setDescription: func(text){
        me.applianceDescription = text;
    },
    setResistance: func(r){
        me.resistance = r;
    },
};

var VoltageSource = {
    #//Class for any voltage source
    #//eR: Internal resistance of the source, eF: Electromotive force of the source, eC: Electrical capacity of the source, name: Name of the source.
    new: func(eR, eF, eC, name = "VoltageSource") {
        var newVS = { parents:[VoltageSource, Appliance.new()], resistance: eR, ratedElectromotiveForce:eF, electromotiveForce:eF, electricalCapacity:eC, applianceName: name };
        newVS.resetRemainingToFull();
        return newVS;
    },

    isVoltageSource: func(){
        return 1;
    },

    direction: 1, #//1 means it is connected in the current direction, -1 means the opposite
    ratedElectromotiveForce: 0, #//Volt
    electromotiveForce: 0, #//Volt
    electricalCapacity: 0, #//kWs
    remaining: 0, #//kWs


    voltageSourceUpdate: func(power, interval){
        me.remaining -= power * 0.001 * interval; #//Pass in negetive power for charging
        if(me.remaining <= 0){
            me.electromotiveForce = 0;
        }else{
            me.electromotiveForce = me.ratedElectromotiveForce;
        }
    },

    #//Usage: followme.circuit_1.parallelConnection[0].units[0].resetRemainingToFull();
    resetRemainingToFull: func(){
        me.remaining = me.electricalCapacity;
    },
    resetRemainingToZero: func(){
        me.remaining = 0;
    },
    getRemainingPercentage: func(){
        return sprintf("%.0f", 100 * me.remaining / me.electricalCapacity)~"%";
    },
    getRemainingPercentageFloat: func(){
        return sprintf("%.0f", 100 * me.remaining / me.electricalCapacity);
    },
    getRemainingInkWh: func(){
        return me.remaining/3600;
    },
    addToBattery: func(num){
        me.remaining += num;
    },

};

var Switch = {
    #//Class for any switches
    #//Type 0 for appliance switch. type 1 for series switch
    #//switchToggle: Return 1 if connected, return 0 if disconnected
    new: func(type, name = "Switch") {
        var newCS = { parents:[Switch, Appliance.new()], applianceName: name, type: type, isResistor: 1,};
        return newCS;
    },
    isSwitch: func(){
        return 1;
    },
    resistance: 3000000000000, #//3000000000000 when disconnected and 0 when connected
    switchState: 1, #//0 for disconnect, 1 for connect

    isConnected: func(){
        if(me.switchState){
            return 1;
        }else if(!me.switchState){
            return 0;
        }
    },

    switchConnect: func(){
        me.switchState = 1;
        me.resistance = 0;
        return 1;
    },
    switchDisconnect: func(){
        me.switchState = 0;
        me.resistance = 3000000000000;
        return 0;
    },
    switchToggle: func(){
        if(me.isConnected()){
            return me.switchDisconnect();
        }else if(!me.isConnected()){
            return me.switchConnect();
        }
    },

};

var Cable = {
    #//Class for any copper electrical cable
    new: func(l = 0, s = 0.008) {
        var newCable = { parents:[Cable, Appliance.new()], applianceName: "Cable", resistivity: 1.75 * 0.00000001, length: l, crossSection: s};
        print("Created Cable with resistance of " ~ newCable.setResistance());
        return newCable;
    },
    length: 0,#//Meter
    crossSection: 0,#//Meter^2
    setResistance: func(){
        me.resistance = (me.resistivity * me.length) / me.crossSection;
        return me.resistance;
    }
};

var cSource = VoltageSource.new(0.0136, 405, kWh2kWs(90), "Battery");#//Battery for engine, 90kWh, 405V
var circuit_1 = Circuit.new(cSource);#//Engine circuit

var cSource_small = VoltageSource.new(0.0136, 12, kWh2kWs(0.72), "Battery");#//Battery for other systems, 60Ah, 12V
cSource_small.resetRemainingToZero();
#circuit_1.addNewSeriesWithUnitToParallel(cSource_small);


#circuit_1.addUnitToSeries(0, Cable.new(10, 0.008));
#circuit_1.addUnitToSeries(0, Switch.new(0));
#circuit_1.addParallel(Switch.new(1));



var electricTimer1 = maketimer(circuit_1.updateInterval, func circuit_1.update());
electricTimer1.simulatedTime = 1;

var L = setlistener("/sim/signals/fdm-initialized", func{
    electricTimer1.start();
});