def createBoard(self, boardLength, boardHeight, n_houses, n_batteries):
""" """
batteryList = []
houseList = []
housePositionList = []
for x in range(n_houses):
newPosition = [randint(0,boardLength), randint(0,boardHeight)]
for x in housePositionList:
if (tuple(x) == tuple(newPosition)):
newPosition[0] = (newPosition[0] + randint(-2,2)) % boardLength
newPosition[1] = (newPosition[1] + randint(-2,2)) % boardHeight
housePositionList.append(newPosition)
for x in range(n_houses):
houseList.append(solarHouse.solarpanelHouse("house" + str(x), randint(5,10), position = housePositionList[x]))
batteryPositionList =[]
for x in range(n_batteries):
newPosition = [randint(0,boardLength), randint(0,boardHeight)]
for x in batteryPositionList:
if (tuple(x) == tuple(newPosition)):
newPosition[0] = (newPosition[0] + 1) % boardLength
newPosition[1] = (newPosition[1] + 1) % boardHeight
for x in housePositionList:
if (tuple(x) == tuple(newPosition)):
newPosition[0] = (newPosition[0] + randint(-2,2)) % boardLength
newPosition[1] = (newPosition[1] + randint(-2,2)) % boardHeight
batteryPositionList.append(newPosition)
Battery.createBatteries(n_batteries, 1000, batteryPositionList, [], batteryList, houseList)
# batteryList.append(Battery.battery( position = [randint(0, boardLength), randint(0, boardHeight)] , "A", 500, [], False))
return houseList, batteryList
class Motor:
def __init__(self, robot, motorLvl, batteryLvl):
self.battery = Battery(batteryLvl)
self.type = motorLvl
self.state = True
self.robot = robot
def checkState(self):
if (self.battery.battery <= 0):
self.state = False
print('Motor apagado robot', self.robot.id)
return self.state
def shutDown(self):
self.battery.consumeAllBattery()
self.checkState()
def consumeBattery(self, cant):
self.battery.consumeBattery(cant)
self.checkState()
def move(self, terrain):
if (terrain.type == 1):
self.battery.consumeBattery(1)
elif (terrain.type == 2):
self.battery.consumeBattery(2)
elif (terrain.type == 3):
self.battery.consumeBattery(3)
self.checkState()
def initial_population(lenght):
robots = []
for count in range(lenght):
# select camera type
c = random.randint(1, 3)
m = random.randint(1, 3)
b = random.randint(1, 3)
robots.append(
Robot(Motor(m, MOTORS[m]), Camera(c, CAMERAS[c, 0], CAMERAS[c, 1]),
Battery(b, BATTERIES[b]), None))
return robots
def createBatteryList(configuration, l, h, houseList): #create batteryList batteryList = [] number = 0 for batterycap in configuration: x = randint(0,l) y = randint(0,h) newpos = [x,y] newbat = Battery.battery(number, batterycap, houseList, False, position = newpos) number += 1 batteryList.append(newbat) return batteryList
def main():
"""Main function to get information for Bar 4.
"""
getter_battery = Battery.Battery()
getter_clock = Clock.Clock()
getter_keyboard = Keyboard.Keyboard()
getter_os = Os.Os()
getter_battery.show_info()
sys.stdout.write(" | ")
getter_clock.get_uptime()
sys.stdout.write(" | ")
getter_clock.get_time()
sys.stdout.write(" ")
getter_clock.get_date()
sys.stdout.write(" | ")
getter_keyboard.get_layout()
getter_keyboard.show_locks()
sys.stdout.write(" | ")
getter_os.get_os()
def paintMenuBar(self, surface=None):
'''
Paint the menubar on a panel
'''
if (surface == None):
surface = self.screen
surface.blit(self.menubar, (0, 0))
surface.blit(self.buttonShell, (70, 0))
surface.blit(self.buttonMusic, (86, 0))
bat = Battery.Battery(self).getValue()
#print bat;
if (bat == 0):
surface.blit(self.batFull, (285, 5))
elif (bat == 1):
surface.blit(self.batHigh, (285, 5))
elif (bat == 2):
surface.blit(self.batLow, (285, 5))
elif (bat == 3):
surface.blit(self.batEmpty, (285, 5))
else:
surface.blit(self.batFull, (285, 5))
surface.blit(self.buttonOff, (305, 0))
def build_robot(binary_setting, parents):
setting_type = []
# set camera type
value = [str(x) for x in binary_setting[0:4]]
value = ''.join(value)
setting_type.append(int(value))
# set motor type
value = [str(x) for x in binary_setting[4:8]]
value = ''.join(value)
setting_type.append(int(value))
# set battery type
value = [str(x) for x in binary_setting[8:12]]
value = ''.join(value)
setting_type.append(int(value))
# set behavior
# build robot
# select motor, battery and camera
robot = Robot(
Motor(setting_type[1], MOTORS[setting_type[1]]),
Camera(setting_type[0], CAMERAS[setting_type[0], 0],
CAMERAS[setting_type[0], 1]),
Battery(setting_type[2], BATTERIES[setting_type[2]]), parents)
return robot
# Initial/default Pump configuration parameters to store in db
first_name = 'Joe'
last_name = 'Doe'
capacity_insulin = 100.0
drip_rate = 1.0
safe_min = 6.0
safe_max = 14.0
max_daily_dose = 25.0
max_single_dose = 4.0
minimum_dose = 1.0
bg_sensor = BloodGlucose.BloodGlucose()
clock = Clock.Clock()
clock_time = clock.getTime()
battery = Battery.Battery()
sqlite_file = 'insulin_pump.sqlite' # name of the sqlite database file
def get_db(table_name, column_name):
try:
conn = sqlite3.connect(sqlite_file)
c = conn.cursor()
except Error as e:
print(e)
else:
c.execute('SELECT ' + column_name + ' FROM ' + table_name)
data = c.fetchone()
return data[0]
conn.close()
def k_means(n_Batteries, n_Houses, boardLength, boardHeight):
# initiation
somethingChanged = True
houseList = []
batteryList = []
# build batteries
for x in xrange(n_Batteries):
newBatt = Battery.battery()
newBatt.name = 'Battery : ' + str(x)
newBatt.position = [
randint(boardLength / 4, 3 * (boardLength / 4)),
randint(boardHeight / 4, 3 * (boardHeight / 4))
]
batteryList.append(newBatt)
# build houses
for x in xrange(n_Houses):
newHouse = solarHouse.solarpanelHouse()
newHouse.position = [randint(0, boardLength), randint(0, boardHeight)]
houseList.append(newHouse)
it = 0
while (somethingChanged):
it += 1
# assignment of houses
for house in houseList:
distances = []
for battery in batteryList:
distances.append(
manhattenDistance(battery.position, house.position))
index = np.argmin(distances)
house.batteryAssignment = batteryList[index]
# relocating batteries
changedlist = []
for battery in batteryList:
# save old location
oldPosition = tuple(battery.position)
# initiate values for new battery-position
n = 0
positionSum = np.array([0, 0])
# check per house if it is assignet to current battery
for house in houseList:
# if so, count its position in
if (house.batteryAssignment == battery):
n += 1
positionSum += house.position
battery.position = list(positionSum / n)
# save wether the battery moved since last time
if (tuple(battery.position) == oldPosition):
changedlist.append(True)
else:
changedlist.append(False)
# stop if no battery changed
if (all(i == True for i in changedlist)):
somethingChanged = False
print it
return houseList, batteryList
def __init__(self, robot, motorLvl, batteryLvl):
self.battery = Battery(batteryLvl)
self.type = motorLvl
self.state = True
self.robot = robot
def create_battery(self):
battery = Battery(self.id)
from Battery import *
# Config Params
Battery.P_GAIN = 15
Battery.I_GAIN = 0.01
Battery.HYST_GAIN = 17.45
Battery.SHORT_TERM_DAMP = 1.8
Battery.SOC_CORRECTION_INTERVAL = 60
# Initialize each cell of the battery pack with an initial state of charge
# Battery(Initial SOC, initial time)
cell = [Battery(95, 0) for _ in range(40)]
# whenever you get new data, call the update method on a particular cell. It returns the current SOC
while True:
instr = raw_input("t,Vt,I,T,cellnum: ")
[t, Vt, I, T, cellnum] = instr.split(",")
SOC_py = cell[eval(cellnum)].Update((eval(Vt) / 10000) - 0.004 * eval(I),
eval(I), eval(T), eval(t))
print "t=" + str(t) + ',SOC=' + str(
round(SOC_py)) + ',cell=' + str(cellnum)
# Some useful info:
# cell[x].Voc = estimate for the open circuit voltage of the cell (depends on several factors)
# cell[x].R0 = estimate for internal resistance of the cell (depends on SOC)
# cell[x].Capacity * cell[x].SOC = coulombs of charge remaining in cell
# cell[x].Capacity * cell[x].SOC * 3600 = Amp-Hours of charge remaining in cell
def __init__(self,make,model,year,price):
super().__init__(make,model,year)
self.battery=0
self.price=price
self.battery=Battery.Battery('海尔')
def __init__(self, marka, speed):
""" инициалзирует атрибуты класса-родителя"""
super().__init__(marka, speed)
self.battery = Battery(240)
def Dispatch(type, controllableLoadPower, curtail, uncontrollableLoadPower,
dayOfYear, localTime, timeZone, longitude, latitude, slope,
globalHorizontalRadiation, clearnessIndex, DNI,
timeStepHourlyFraction, DFI, groundReflectance, inverterEff,
pvCapacity, invertCapacity, startTOU, stopTOU, currentCapacity,
nominalCapacity, minCapacityAsFractoin, chargeEff, dischargeEff,
maxCRate, nominalVoltage):
#run system simulation
#TODO: needs lots of conditional logic here to handle various use cases
powerOutputDC = 0
powerOutputAC = 0
batteryPower = 0
EnergyNet = 0
batteryCurrentCapacity = 0
batterySOC = 0
if type == 'loads': #no generators or additional loads(vehicle)...battery only charges from solarPV
totalLoadPower = Load.Load(controllableLoadPower, curtail,
uncontrollableLoadPower)
EnergyNet = totalLoadPower
powerOutputDC = 0
powerOutputAC = 0
batteryPower = 0
batteryCurrentCapacity = 0
batterySOC = 0
elif type == 'solarPV & & inverter': #solar generator
powerOutputDC = SolarPV.SolarPV(dayOfYear, localTime, timeZone,
longitude, latitude, slope,
globalHorizontalRadiation,
clearnessIndex, DNI,
timeStepHourlyFraction, DFI,
groundReflectance, pvCapacity)
powerOutputAC = Inverter.Inverter(powerOutputDC, inverterEff,
pvCapacity, invertCapacity)
totalLoadPower = Load.Load(controllableLoadPower, curtail,
uncontrollableLoadPower)
EnergyNet = totalLoadPower - powerOutputAC
batteryPower = 0
batteryCurrentCapacity = 0
batterySOC = 0
elif type == 'solarPV & & inverter && battery': #solar and battery
powerOutputDC = SolarPV.SolarPV(dayOfYear, localTime, timeZone,
longitude, latitude, slope,
globalHorizontalRadiation,
clearnessIndex, DNI,
timeStepHourlyFraction, DFI,
groundReflectance, pvCapacity)
powerOutputAC = Inverter.Inverter(powerOutputDC, inverterEff,
pvCapacity, invertCapacity)
totalLoadPower = Load.Load(controllableLoadPower, curtail,
uncontrollableLoadPower)
batteryPower = 0
#here is the dispatch logic...
# - charge battery with solar
# - send excess to meet load
# - discharge battery during TOU period battery to avoid high grid price...assume 12-8PM
hourOfDay = localTime
if (hourOfDay < startTOU
and hourOfDay > stopTOU): #outside TOU, don't use battery
batteryPower, maxChargeEnergy = Battery.BatteryGetMaximumChargePower(
currentCapacity, timeStepHourlyFraction, nominalCapacity,
nominalVoltage, minCapacityAsFractoin, chargeEff, dischargeEff,
maxCRate)
if (batteryPower > 0):
powerOutputDC = SolarPV.SolarPV(dayOfYear, localTime, timeZone,
longitude, latitude, slope,
globalHorizontalRadiation,
clearnessIndex, DNI,
timeStepHourlyFraction, DFI,
groundReflectance, pvCapacity)
powerOutputAC = Inverter.Inverter(powerOutputDC, inverterEff,
pvCapacity, invertCapacity)
batteryPower, maxChargeEnergy = Battery.BatteryGetMaximumChargePower(
currentCapacity, timeStepHourlyFraction, nominalCapacity,
nominalVoltage, minCapacityAsFractoin, chargeEff,
dischargeEff, maxCRate)
if (powerOutputDC >
batteryPower): #more solar than can put into battery
batteryPower = (-1.0 * batteryPower
) #switch sign so we know it is charging
powerOutputDC = powerOutputDC - batteryPower #send remaining to load
powerOutputAC = Inverter.Inverter(powerOutputDC,
inverterEff, pvCapacity,
invertCapacity)
totalLoadPower = Load.Load(controllableLoadPower, curtail,
uncontrollableLoadPower)
EnergyNet = totalLoadPower - powerOutputAC
else: #battery requires all solar power, no solar pushed to loads
batteryPower = (-1.0 * powerOutputDC)
powerOutputDC = batteryPower # send remaining to load
powerOutputAC = 0
totalLoadPower = Load.Load(controllableLoadPower, curtail,
uncontrollableLoadPower)
EnergyNet = totalLoadPower
else: #no room to charge battery, just push solar to AC
batteryPower = 0 #still need to do, else numbers don't update
powerOutputDC = SolarPV.SolarPV(dayOfYear, localTime, timeZone,
longitude, latitude, slope,
globalHorizontalRadiation,
clearnessIndex, DNI,
timeStepHourlyFraction, DFI,
groundReflectance, pvCapacity)
powerOutputAC = Inverter.Inverter(powerOutputDC, inverterEff,
pvCapacity, invertCapacity)
totalLoadPower = Load.Load(controllableLoadPower, curtail,
uncontrollableLoadPower)
EnergyNet = totalLoadPower - powerOutputAC
else: #inside TOU, use battery if possible
powerOutputDC = SolarPV.SolarPV(dayOfYear, localTime, timeZone,
longitude, latitude, slope,
globalHorizontalRadiation,
clearnessIndex, DNI,
timeStepHourlyFraction, DFI,
groundReflectance, pvCapacity)
powerOutputAC = Inverter.Inverter(powerOutputDC, inverterEff,
pvCapacity, invertCapacity)
totalLoadPower = Load.Load(controllableLoadPower, curtail,
uncontrollableLoadPower)
EnergyNet = totalLoadPower - powerOutputAC # send remaining to grid
batteryPower, maxChargeEnergy = Battery.BatteryGetMaximumChargePower(
currentCapacity, timeStepHourlyFraction, nominalCapacity,
nominalVoltage, minCapacityAsFractoin, chargeEff, dischargeEff,
maxCRate)
if (EnergyNet < 0): #use excess power to charge battery
excessDC = -1 * (
EnergyNet / inverterEff
) #change back to DC and sign from negative to positive
if batteryPower > 0:
if excessDC > batteryPower: #more solar than can put into battery
batteryPower = (
-1.0 * batteryPower
) #switch sign so we know it is charging
powerOutputDC = excessDC - batteryPower #send remaining to grid
powerOutputAC = Inverter.Inverter(
powerOutputDC, inverterEff, pvCapacity,
invertCapacity)
EnergyNet = -1 * (powerOutputAC
) #send remaining to grid
else: #battery requires all solar power, no excess solar pushed to grid
batteryPower = (
-1.0 * excessDC
) # switch sign so we know it is charging
powerOutputDC = excessDC
powerOutputAC = 0
EnergyNet = 0
else: #no room to charge battery, just push solar to AC
batteryPower = 0 #still need to do, else numbers don't update
powerOutputDC = excessDC
powerOutputAC = Inverter.Inverter(excessDC, inverterEff,
pvCapacity,
invertCapacity)
EnergyNet = -1 * (powerOutputAC) # send remaining to grid
else: #try use battery to meet load
deficitAC = totalLoadPower - powerOutputAC #how much AC load battery has to supply
deficitDC = deficitAC / inverterEff #account for DC to AC efficiency
batteryPower, maxDischargeEnerg = Battery.BatteryGetMaximumDischargePower(
currentCapacity, timeStepHourlyFraction, nominalCapacity,
nominalVoltage, minCapacityAsFractoin, chargeEff,
dischargeEff, maxCRate)
if (batteryPower > 0):
if (deficitDC > batteryPower
): #need more power than battery can deliver
batteryPower = (batteryPower
) #positive sign means discharging
powerOutputDC = powerOutputDC + batteryPower #account for extra battery power going into inverter
powerOutputAC = Inverter.Inverter(
powerOutputDC, inverterEff, pvCapacity,
invertCapacity) #solar output + battery output
EnergyNet = totalLoadPower - powerOutputAC
else: #battery can meet deficit DC that solar PV cannot
batteryPower = (deficitDC)
powerOutputDC = powerOutputDC + batteryPower # account for extra battery power going into inverter
powerOutputAC = Inverter.Inverter(
powerOutputDC, inverterEff, pvCapacity,
invertCapacity) # solar output + battery output
EnergyNet = totalLoadPower - powerOutputAC
else: #no energy in battery to use
batteryPower = 0 # still need to do, else numbers don't update
powerOutputDC = powerOutputDC + batteryPower # account for extra battery power going into inverter
powerOutputAC = Inverter.Inverter(
powerOutputDC, inverterEff, pvCapacity,
invertCapacity) # solar output + battery output
EnergyNet = totalLoadPower - powerOutputAC
batteryCurrentCapacity, batterySOC = Battery.BatteryCapacity(
batteryPower, currentCapacity, nominalVoltage, nominalCapacity)
return powerOutputDC, powerOutputAC, batteryPower, EnergyNet, batteryCurrentCapacity, batterySOC
import Fans as f
import Motor as m
import Inverter as i
import Battery as b
Vs = 230 # Standard System Voltage, selected because: minimum sparkover voltage is 327 V
f.GetPerformance()
PowerLimits, RPMLimits = m.Motor()
DCPowerLimits = i.Inverter(PowerLimits, RPMLimits, Vs)
PackCost = b.Battery(DCPowerLimits, Vs)
print(' ')
motorDiameter, motorL = m.Sizing(PowerLimits[1], Vs)
inverterVolume = i.Sizing(motorDiameter, motorL)
b.Sizing()
from Battery import *
# Open Testing File
#fin = open('sim_3600_pulse.csv', 'r')
#fout = open('sim_3600_pulse_out.csv', 'w')
fin = open('sim_glasgow.csv', 'r')
fout = open('sim_glasgow_out.csv', 'w')
Battery.P_GAIN = 15
Battery.I_GAIN = 0.01
Battery.HYST_GAIN = 17.45
Battery.SHORT_TERM_DAMP = 1.8
Battery.SOC_CORRECTION_INTERVAL = 60
# Battery(Initial SOC, initial time)
cell0 = Battery(95, 0)
fin.readline()
for line in fin:
# [t,I,Vt,T,SOC_matlab] = line.split(',')
[t, I, Vt, T, dummy] = line.split(',')
SOC_py = cell0.Update((eval(Vt) / 10000) - 0.004 * eval(I), eval(I),
eval(T), eval(t))
#fout.write(str(t) + ',' + str(SOC_py) + ',' + str(SOC_matlab) )
fout.write(str(t) + ',' + str(SOC_py) + '\n')
print str(t) + ',' + str(SOC_py)