def setup(hass, base_config):
"""Set up of Tesla component."""
from tesla_api import TeslaApiClient, AuthenticationError, ApiError
config = base_config.get(DOMAIN)
email = config.get(CONF_USERNAME)
password = config.get(CONF_PASSWORD)
scan_interval = config.get(CONF_SCAN_INTERVAL)
api_client = TeslaApiClient(email, password)
try:
_LOGGER.info('Initializing Tesla data manager')
vehicles = api_client.list_vehicles()
data_manager = TeslaDataManager(hass, vehicles, scan_interval)
hass.data[DOMAIN] = {DATA_MANAGER: data_manager}
_LOGGER.info('Tesla data manager intialized')
_LOGGER.debug('Connected to the Tesla API, found {} vehicles.'.format(
len(vehicles)))
except AuthenticationError as ex:
_LOGGER.error(ex.message)
return False
except ApiError as ex:
_LOGGER.error(ex.message)
return False
for platform in TESLA_PLATFORMS:
discovery.load_platform(hass, platform, DOMAIN, None, base_config)
return True
async def getreserve():
token = await load_token()
client = TeslaApiClient(token=token, on_new_token=save_token)
client.authenticate()
energy_sites = await client.list_energy_sites()
assert(len(energy_sites)==1)
reserve = await energy_sites[0].get_backup_reserve_percent()
await client.close()
print(reserve)
return reserve
async def main_energy(email, password, token):
client = TeslaApiClient(email, password, token, on_new_token=save_token)
energy_sites = await client.list_energy_sites()
print("Number of energy sites = %d" % (len(energy_sites)))
assert (len(energy_sites) == 1)
reserve = await energy_sites[0].get_backup_reserve_percent()
print("Backup reserve percent = %d" % (reserve))
print("Increment backup reserve percent")
await energy_sites[0].set_backup_reserve_percent(reserve + 1)
client.close()
def setup(hass, base_config):
"""Set up of Tesla component."""
from tesla_api import TeslaApiClient, AuthenticationError, ApiError
config = base_config.get(DOMAIN)
email = config.get(CONF_USERNAME)
password = config.get(CONF_PASSWORD)
scan_interval = config.get(CONF_SCAN_INTERVAL)
api_client = TeslaApiClient(email, password)
try:
_LOGGER.info('Initializing Tesla data manager')
vehicles = api_client.list_vehicles()
data_manager = TeslaDataManager(hass, vehicles, scan_interval)
hass.data[DOMAIN] = {DATA_MANAGER: data_manager}
_LOGGER.info('Tesla data manager intialized')
_LOGGER.debug('Connected to the Tesla API, found %d vehicles.',
len(vehicles))
except AuthenticationError as ex:
_LOGGER.error(ex.message)
return False
except ApiError as ex:
_LOGGER.error(ex.message)
return False
def execute_controls_service(call):
vin = call.data.get(ATTR_VIN)
vehicle = data_manager.get_vehicle(vin)
if not vehicle:
_LOGGER.error('No vehicle found with VIN %s', vin)
return
func = getattr(vehicle.controls, call.service)
vehicle.wake_up()
func()
for service in CONTROLS_SERVICES:
hass.services.register(DOMAIN,
service,
execute_controls_service,
schema=SERVICE_SCHEMA)
for platform in TESLA_PLATFORMS:
discovery.load_platform(hass, platform, DOMAIN, None, base_config)
return True
def user_page(user_id):
"""Show the vehicle data associated with the user."""
user_id = str(user_id)
now = int(time())
user_data = db.get_user(user_id)
if not user_data:
abort(404)
if now < user_data['begins_at']:
return render_template("user_wait.html",
title=TITLE,
begins_at=user_data['begins_at'])
if now > user_data['expires_at']:
db.delete_user(user_id)
abort(404)
client = TeslaApiClient(token=user_data['token'])
try:
# Make sure the token and vehicle_id are valid
vehicle = client.get_vehicle(user_data['vehicle_id'])
except AuthenticationError:
abort(403)
# Return template immediately and fill the rest with JSON-requests.
if not request.args.get('json'):
return render_template("user_page.html",
title=TITLE,
user_id=user_id,
vehicle_name=vehicle.display_name)
api_error = False
response = {}
try:
if vehicle.state != "online":
_resp = vehicle.wake_up()
data = vehicle.get_data()
response['battery_level'] = data['charge_state'].get('battery_level')
response['charging_state'] = data['charge_state'].get('charging_state')
response['is_climate_on'] = data['climate_state'].get('is_climate_on')
response['temp_setting'] = data['climate_state'].get(
'driver_temp_setting')
response['inside_temp'] = data['climate_state'].get('inside_temp')
response['outside_temp'] = data['climate_state'].get('outside_temp')
response['gui_temperature_units'] = data['gui_settings'].get(
'gui_temperature_units')
response['locked'] = data['vehicle_state'].get('locked')
response['vehicle_name'] = vehicle.display_name
except ApiError as error_msg:
api_error = True
LOG.info("Remote API error: %s", error_msg)
return jsonify(response=response, api_error=api_error)
async def main():
# reminder got this original token from postman auth thingo using authcode with pkce settings
#o = {}
#o["refresh_token"] = ""
#o["access_token"] = ""
#o["expires_in"]=28800
#o["created_at"] = datetime.timestamp(datetime.now())
#tokens = json.dumps(o)
#await save_token(tokens)
#exit()
tokens = await load_token()
client = TeslaApiClient(token=tokens, on_new_token=save_token)
energy_sites = await client.list_energy_sites()
print("Number of energy sites = %d" % (len(energy_sites)))
assert (len(energy_sites) == 1)
reserve = await energy_sites[0].get_backup_reserve_percent()
print("Backup reserve percent = %d" % (reserve))
print("Increment backup reserve percent")
#await energy_sites[0].set_backup_reserve_percent(0)
await client.close()
async def main():
try:
client = TeslaApiClient('YourPowerwallUsername',
'YourPowerwallPassword')
energy_sites = await client.list_energy_sites()
reserve = await energy_sites[0].get_backup_reserve_percent()
charge = await energy_sites[
0].get_energy_site_live_status_percentage_charged(
) / 100 * powerwallCapacity
await energy_sites[0].set_backup_reserve_percent(reserve + 1)
solarForecast = int(getSolarForecast.forecast)
shortfall = homeRequirements - (
solarForecast + charge - 1.34
) # The value 1.34 represents 10% of a single Powerwall 2 capacity. This reserve is a personal choice.
if shortfall > 13.4:
# Tesla recommend that the Powerwall should not be charged from the grid to 100%, hence stop at 99%
await energy_sites[0].set_backup_reserve_percent(99)
elif shortfall < 10:
# I prefer 10% as a minimum value following overnight charging
await energy_sites[0].set_backup_reserve_percent(10)
else:
# Set reserve to calculated amount
await energy_sites[0].set_backup_reserve_percent(batteryReserve)
except:
pass
await client.close()
async def main_vehicle(email, password, token):
async with TeslaApiClient(email, password, token,
on_new_token=save_token) as client:
vehicles = await client.list_vehicles()
for v in vehicles:
print(v.vin)
await v.controls.flash_lights()
async def something():
client = TeslaApiClient(username, password)
vehicles = await client.list_vehicles()
v = vehicles[0]
await v.wake_up()
data = await v.full_update()
diff(FULL_DATA, v._data, changes, fixup)
async def main():
client = TeslaApiClient('username', 'password')
energy_sites = await client.list_energy_sites()
reserve = await energy_sites[0].get_backup_reserve_percent()
await energy_sites[0].set_backup_reserve_percent(5)
print("Backup reserve changed to 5%.")
await client.close()
async def setreserve(percent):
token = await load_token()
client = TeslaApiClient(token=token, on_new_token=save_token)
energy_sites = await client.list_energy_sites()
assert(len(energy_sites)==1)
print("Increment backup reserve percent")
await energy_sites[0].set_backup_reserve_percent(int(percent))
await client.close()
return "OK"
async def main():
while True:
try:
(username, password) = get_credentials('*****@*****.**')
client = TeslaApiClient(username, password)
await client.authenticate()
print('"token": ', json.dumps(client.token, indent=4))
await client.close()
break
except:
print('this did not work, let us ttry taht again')
async def main():
client = TeslaApiClient('*****@*****.**', '2CF@wS4xGYdB')
vehicles = await client.list_vehicles()
print(vehicles.__len__())
for v in vehicles:
print(v.vin)
await v.controls.flash_lights()
await client.close()
def login():
"""After login, choose vehicle and access duration."""
email = password = token = error_msg = csrf = None
if request.form['token']:
token = _get_token(refresh_token=request.form['token'])
elif request.form['email'] and request.form['password']:
email = request.form['email']
password = request.form['password']
else:
abort(400)
if RECAPTCHA_SITE_KEY:
try:
response = request.form[RECAPTCHA_RESPONSE_PARAM]
except ValueError:
abort(400)
if verify_recaptcha(response, RECAPTCHA_SITE_SECRET):
LOG.info('reCAPTCHA success')
else:
LOG.warning('reCAPTCHA failure')
error_msg = 'reCAPTCHA failure'
client = TeslaApiClient(email, password, token)
vehicles = token = None
if error_msg is None:
try:
vehicles = client.list_vehicles()
token = client.token['refresh_token']
csrf = make_csrf_token(token, SECRET_KEY)
except AuthenticationError:
error_msg = 'Authentication failure'
return render_template("login.html",
title=TITLE,
vehicles=vehicles,
token=token,
csrf=csrf,
max_access_duration=MAX_ACCESS_DURATION,
error_msg=error_msg)
def main(argv):
newmode = ''
try:
opts, args = getopt.getopt(argv, "hm:", ["mode="])
except getopt.GetoptError:
print_helptext()
sys.exit(2)
for opt, arg in opts:
if opt == "-h":
print_helptext()
sys.exit(0)
elif opt in ("-m", "--mode"):
newmode = arg
config = ConfigParser()
configpath = get_script_path() + '/../etc/secrets.cfg'
config.read(configpath)
try:
client = TeslaApiClient(config["api"]["email"], config["api"]["password"])
energy_sites = client.list_energy_sites()
assert(len(energy_sites)==1)
if newmode == 'backup':
energy_sites[0].set_operating_mode_backup()
energy_sites[0].set_backup_reserve_percent(100)
elif newmode == 'self_consumption':
energy_sites[0].set_operating_mode_self_consumption()
energy_sites[0].set_backup_reserve_percent(0)
elif newmode == 'autonomous':
energy_sites[0].set_operating_mode_autonomous()
energy_sites[0].set_backup_reserve_percent(0)
else:
print("Invalid mode selected")
sys.exit(2)
sys.exit(0)
except AuthenticationError as e:
print("AuthenticationError: " + e)
sys.exit(1)
def api():
"""API to control the vehicle."""
commands = ['start_climate', 'stop_climate']
now = int(time())
try:
user_id = request.form['user_id']
command = request.form['command']
except ValueError:
abort(400)
if not command in commands:
abort(400)
user_data = db.get_user(user_id)
if not user_data:
abort(403)
if now < user_data['begins_at']:
abort(403)
if now > user_data['expires_at']:
db.delete_user(user_id)
abort(403)
client = TeslaApiClient(token=user_data['token'])
try:
# Make sure the token and vehicle_id are valid
vehicle = client.get_vehicle(user_data['vehicle_id'])
except AuthenticationError:
abort(403)
try:
if command == 'start_climate':
data = vehicle.climate.start_climate()
if command == 'stop_climate':
data = vehicle.climate.stop_climate()
except ApiError as error_msg:
data = {'result': False}
LOG.info("Remote API error: %s", error_msg)
return jsonify(data)
async def main():
with open('tesla-monitoring.conf.json') as conf_file:
config = json.load(conf_file)
alert_mgr = AlertManager(config['alerting'])
try:
client = TeslaApiClient(token=config["token"])
vehicles = await client.list_vehicles()
vehicle = [ vehicle for vehicle in vehicles if vehicle.display_name == config["vehicle_name"] ][0]
if vehicle is None:
raise VehicleNotFoundException('Vehicle {} not found'.format(config["vehicle_name"]))
sch_mgr = ScheduleManager(config["locations"], alert_mgr)
if not sch_mgr.filter_schedules_by_timeslot():
raise NoScheduleException("Cannot find applicable schedule")
# if vehicle is offline, check if any of the schedules allow waking up. Wake up or quit
if vehicle.state != 'online':
if sch_mgr.can_wake_up():
alert_mgr.info("One or more schedules allow vehicle to be woken up")
await vehicle.wake_up()
while True:
try:
time.sleep(3)
drive_state = await vehicle.get_drive_state()
break
except:
pass
else:
raise VehicleOfflineException("Vehicle is offline, and none of the schedules allow wake up")
else:
drive_state = await vehicle.get_drive_state()
if not sch_mgr.filter_schedules_by_location(drive_state["latitude"], drive_state["longitude"]):
raise NoLocationException("Vehicle is not at a known location")
charge_state = await vehicle.charge.get_state()
sch_mgr.validate_state(charge_state['charging_state'])
except (VehicleOfflineException,NoScheduleException,NoLocationException) as ex:
alert_mgr.info(ex)
except Exception as ex:
alert_mgr.alert(ex)
finally:
await client.close()
def authorize():
"""Authorize access and show the URL for user page."""
if not check_csrf_token(request.form['token'], SECRET_KEY,
request.form['csrf']):
LOG.warning('CSRF failed')
abort(403)
try:
vehicle_id = request.form['vehicle']
begins_at = int(request.form['begins_at'])
expires_at = int(request.form['expires_at'])
assert vehicle_id.isnumeric()
assert 0 <= begins_at <= MAX_ACCESS_DURATION - 1
assert 1 <= expires_at <= MAX_ACCESS_DURATION
assert begins_at < expires_at
except (ValueError, AssertionError) as _error_msg:
abort(400)
token = _get_token(refresh_token=request.form['token'])
client = TeslaApiClient(token=token)
try:
# Make sure the token and vehicle_id are valid
_data = client.get_vehicle(vehicle_id)
except AuthenticationError:
abort(403)
user_id = str(uuid4())
# Convert submitted times to Unix timestamps
now = int(time())
begins_at = now + begins_at * 3600
expires_at = now + expires_at * 3600
data = {
"token": client.token,
"vehicle_id": vehicle_id,
"begins_at": begins_at,
"expires_at": expires_at
}
db.add_user(user_id, data)
return render_template("authorize.html", title=TITLE, user_id=user_id)
async def main():
"""
Main program loop for looping through all of the cars and metrics
"""
# Connect to Statsd
statsd_server = "statsd-service.metrics.svc.cluster.local"
# statsd_server = "metrics.thesniderpad.com"
statsd_connection = statsd.StatsClient(statsd_server, 8125)
# Which metrics collections are we interested in
metrics_collections = [
"charge_state",
"climate_state",
"drive_state",
"gui_settings",
"vehicle_config",
"vehicle_state",
]
# Connect to the tesla api
username = os.environ["SECRET_USERNAME"]
password = os.environ["SECRET_PASSWORD"]
client = TeslaApiClient(username, password)
# Grab all of the vehicles
vehicles = await client.list_vehicles()
# loop through all the vehicls found
for v in vehicles:
# Get python data representation of api objects
if v.state == "offline":
print("Vehicle is not available")
continue # Vehicle is offline, go to the next one (should we ever have one)
else:
data = await v.get_data()
# Log all of the metrics for each collection
for collection in metrics_collections:
for item in data[collection]:
log_metric(
statsd_connection,
data["display_name"],
item,
data[collection][item],
)
await client.close()
async def main():
pp = pprint.PrettyPrinter(indent=2)
email = password = None
token = read_token()
if token is None:
hvac_client = get_hvac_client()
creds = get_login_credentials(hvac_client)
email = creds["username"]
password = creds["password"]
async with TeslaApiClient(
email, password, token, on_new_token=save_token
) as client:
energy_sites = await client.list_energy_sites()
print(f"Number of energy sites = {len(energy_sites)}")
# We only expect there to be a single site for our home
# (Apricot Systematic)
#
assert len(energy_sites) == 1
site_as01 = energy_sites[0]
reserve = await site_as01.get_backup_reserve_percent()
print(f"Backup reserve percent = {reserve}")
operating_mode = await site_as01.get_operating_mode()
print(f"Operating mode: {operating_mode}")
version = await site_as01.get_version()
print(f"Version: {version}")
battery_count = await site_as01.get_battery_count()
print(f"Battery count: {battery_count}")
# history_energy = await site_as01.get_energy_site_calendar_history_data(
# kind="energy", period="lifetime"
# )
# print(f"History energy: \n{pp.pformat(history_energy)}")
# history_sc = await site_as01.get_energy_site_calendar_history_data(
# kind="self_consumption", period="lifetime"
# )
# print(f"History self consumption:\n{pp.pformat(history_sc)}")
while True:
live_status = await site_as01.get_energy_site_live_status()
print(f"Site live status:\n{pp.pformat(live_status)}")
time.sleep(150)
async def main():
pp = pprint.PrettyPrinter(indent=2)
email = password = None
token = read_token()
if token is None:
hvac_client = get_hvac_client()
creds = get_login_credentials(hvac_client)
email = creds["username"]
password = creds["password"]
async with TeslaApiClient(
email, password, token, on_new_token=save_token
) as client:
energy_sites = await client.list_energy_sites()
print(f"Number of energy sites = {len(energy_sites)}")
# We only expect there to be a single site for our home
# (Apricot Systematic)
#
assert len(energy_sites) == 1
site_as01 = energy_sites[0]
reserve = await site_as01.get_backup_reserve_percent()
print(f"Backup reserve percent = {reserve}")
operating_mode = await site_as01.get_operating_mode()
print(f"Operating mode: {operating_mode}")
version = await site_as01.get_version()
print(f"Version: {version}")
battery_count = await site_as01.get_battery_count()
print(f"Battery count: {battery_count}")
live_status = await site_as01.get_energy_site_live_status()
print(f"Site live status:\n{pp.pformat(live_status)}")
while True:
live_status = await site_as01.get_energy_site_live_status()
print(
f"{datetime.now()} Battery charge: {live_status['percentage_charged']}%"
)
history_power = (
await site_as01.get_energy_site_calendar_history_data(
kind="power", period="day"
)
)
matplotlib_ts(history_power["time_series"])
async def get_tesla():
tesla_client = None
my_tesla = None
charge_port = True
tesla_client = TeslaApiClient(auth.TESLAUSERNAME, auth.TESLAPASSWORD)
vehicles = await tesla_client.list_vehicles()
try:
if None is my_tesla:
if tesla_client is not None:
tesla_client.close()
tesla_client = TeslaApiClient(auth.TESLAUSERNAME,
auth.TESLAPASSWORD)
vehicles = await tesla_client.list_vehicles()
for v in vehicles:
if v.vin == '5YJYGDEE9LF035958':
my_tesla = v
if my_tesla.state == 'online':
try:
charge = await my_tesla.charge.get_state()
except Exception as e:
print("Exception A: " + str(e))
await tesla_client.close()
my_tesla = None
tesla_client = None
else:
await tesla_client.close()
my_tesla = None
tesla_client = None
except AttributeError as error:
await tesla_client.close()
tesla_client = None
print(error)
async def main():
client = TeslaApiClient('TESLA ACCOUNT EMAIL GOES HERE', 'TESLA ACCOUNT PASSWORD GOES HERE')
vehicles = await client.list_vehicles()
for v in vehicles:
await v.wake_up()
print(v.display_name)
state = await v.charge.get_state()
state2 = await v.climate.get_state()
print("{:0.0f}% Battery Level.".format(state["battery_level"]))
print("{:0.0f} Miles of Range.".format(state["battery_range"]))
print("{:0.0f}ºc Inside temperature.".format(state2["inside_temp"]))
print("Charger is currently {}".format(state["charging_state"]))
print("{} Minutes to charging complete".format(state["minutes_to_full_charge"]))
text_to_draw = (v.display_name)
text_to_draw2 = ("{:0.0f}%".format(state["battery_level"]))
text_to_draw3 = ("{:0.0f}m".format(state["battery_range"]))
text_to_draw4 = ("{:0.0f}ºc".format(state2["inside_temp"]))
text_to_draw5 = ("{}".format(state["charging_state"]))
text_to_draw6 = ("{} mins".format(state["minutes_to_full_charge"]))
face_image = make_text_image(text_to_draw, 10, 20, font_file)
face_image2 = make_text_image(text_to_draw2, 45, 20, font_file)
face_image3 = make_text_image(text_to_draw3, 35, 20, font_file)
face_image4 = make_text_image(text_to_draw4, 35, 20, font_file)
face_image5 = make_text_image(text_to_draw5, 0, 20, font_file2)
face_image6 = make_text_image(text_to_draw6, 10, 20, font_file)
args = anki_vector.util.parse_command_args
with anki_vector.Robot() as robot:
current_directory = os.path.dirname(os.path.realpath(__file__))
image_path = os.path.join(current_directory, "images", "Tesla_Vector.jpg")
image_file = Image.open(image_path)
screen_data = anki_vector.screen.convert_image_to_screen_data(image_file)
duration_s = 1.0
robot.behavior.set_head_angle(degrees(25.0))
robot.screen.set_screen_with_image_data(screen_data, duration_s)
robot.behavior.say_text('Your Tesla', True, 1.1)
screen_data = anki_vector.screen.convert_image_to_screen_data(face_image)
robot.screen.set_screen_with_image_data(screen_data, 3.0, interrupt_running=True)
robot.behavior.say_text(v.display_name, True, 0.9)
screen_data2 = anki_vector.screen.convert_image_to_screen_data(face_image2)
robot.screen.set_screen_with_image_data(screen_data2, 4.0, interrupt_running=True)
robot.behavior.say_text('is currently at' + str(state["battery_level"]) + 'percent battery level', True, 1.1)
screen_data3 = anki_vector.screen.convert_image_to_screen_data(face_image3)
robot.screen.set_screen_with_image_data(screen_data3, 4.0, interrupt_running=True)
robot.behavior.say_text('which is' + str("{:0.0f}".format(state["battery_range"]) + 'miles of range'))
screen_data4 = anki_vector.screen.convert_image_to_screen_data(face_image4)
robot.screen.set_screen_with_image_data(screen_data4, 4.0, interrupt_running=True)
robot.behavior.say_text('The interior temperature is' + str("{:0.0f}".format(state2["inside_temp"]) + 'degrees celseeus'))
if (state["charging_state"]) == 'Charging':
screen_data5 = anki_vector.screen.convert_image_to_screen_data(face_image5)
robot.screen.set_screen_with_image_data(screen_data5, 4.0, interrupt_running=True)
robot.behavior.say_text((v.display_name) + " is currently {}".format(state["charging_state"]))
time.sleep(0.2)
screen_data6 = anki_vector.screen.convert_image_to_screen_data(face_image6)
robot.screen.set_screen_with_image_data(screen_data6, 4.0, interrupt_running=True)
robot.behavior.say_text(' and will complete charging in {}'.format(state["minutes_to_full_charge"]) + ' minutes', )
if (state["battery_level"] <= 20):
robot.behavior.say_text('you may want to consider charging up' + (v.display_name) + '. Touch my back sensor to open the charge port', True, 1.1)
while True:
if robot.touch.last_sensor_reading.is_being_touched:
robot.audio.stream_wav_file("sounds/Robot_blip_low.wav", 85)
await (v.controls.open_charge_port())
print('Charge Port Opened')
robot.behavior.say_text('Charge Port Opened')
break
if (state["battery_level"] >= 90):
current_directory = os.path.dirname(os.path.realpath(__file__))
image_path = os.path.join(current_directory, "images", "tesla_icon.jpg")
image_file = Image.open(image_path)
screen_data = anki_vector.screen.convert_image_to_screen_data(image_file)
duration_s = 1.0
robot.behavior.set_head_angle(degrees(25.0))
robot.screen.set_screen_with_image_data(screen_data, duration_s)
robot.behavior.say_text((v.display_name) + 'is ready to drive!, Touch my back sensor to open the doors', True, 1.1)
while True:
if robot.touch.last_sensor_reading.is_being_touched:
await v.controls._vehicle._command('door_unlock')
robot.audio.stream_wav_file("sounds/Robot_blip_low.wav", 85)
print('Doors unlocked')
robot.behavior.say_text('doors unlocked')
time.sleep(180)
await v.controls._vehicle._command('door_lock')
print('Doors Auto locked')
robot.behavior.say_text('doors auto locked')
break
await client.close()
async def main():
async with TeslaApiClient(email, password,
on_new_token=save_token) as client:
await client.authenticate()
from tesla_api import TeslaApiClient
import requests
import time
import json
previouslyActive = True
while True:
try:
client = TeslaApiClient('*****@*****.**', 'yourteslapassword')
vehicles = client.list_vehicles()
v = vehicles[0]
state = v.state
if (state == 'asleep'):
print("Asleep. Waiting for 5 minutes...")
previouslyActive = False
time.sleep(5 * 60)
else:
print("getting data...")
drive_state = v.get_drive_state()
charge = v.charge.get_state()
#print(charge)
print(drive_state)
speed = drive_state['speed']
shift_state = drive_state['shift_state']
if (speed == None):
speed = 0.0
else:
speed = float(speed) * 1.60934 # convert to km/h
payload = {}
payload.update(timestamp=int(round(time.time() * 1000)))
location = {}
def authenticate(username, password):
client = TeslaApiClient(username, password)
print("Authenticating...")
client.authenticate()
return client
async def main():
client = TeslaApiClient('*****@*****.**', 'Illawarra(99)')
while True:
try:
energy_sites = await client.list_energy_sites()
batteryReserve = await energy_sites[0].get_backup_reserve_percent()
batteryPercentage = await energy_sites[
0].get_energy_site_live_status_percentage_charged()
homeUsage = await energy_sites[0].get_home_usage() / 1000
gridUsage = await energy_sites[0].get_grid_usage() / 1000
batteryValue = await energy_sites[0].get_battery_value() / 1000
solarGeneration = await energy_sites[0].get_solar_power() / 1000
availablePower = 13.4 * batteryPercentage / 100
print(datetime.datetime.now())
print("Backup reserve percent = " +
"{:.1f}".format(batteryReserve))
print("Battery percentage = " +
"{:.1f}".format(batteryPercentage))
print("Home usage = " + "{:.2f}".format(homeUsage))
print("Grid usage = " + "{:.2f}".format(gridUsage))
print("Battery value = " + "{:.2f}".format(batteryValue))
print("Solar generation = " +
"{:.2f}".format(solarGeneration))
# The sign of batteryValue determines the charging status of the battery;
# - if positive, then the battery is discharging
# - zero, then the battery is in standby mode
# - if negative, then the battery is charging
# The value of batteryValue determines the charge transfer of the battery
# Here I change the sign of the batteryValue to be more intuative on the graph
if batteryValue > 0:
batteryValue = -1 * batteryValue
elif batteryValue < 0:
batteryValue = abs(batteryValue)
if batteryValue > .050:
print("Battery is charging")
chargingStatus = "Charging"
elif batteryValue < -0.050:
print("Battery is discharging")
chargingStatus = "Discharging"
else:
print("Battery is in Standby mode")
chargingStatus = "Standby"
print("")
aio.send(homeUseage_feed.key, str(homeUsage))
aio.send(solarOutput_feed.key, str(solarGeneration))
aio.send(currentCharge_feed.key, str(batteryPercentage))
aio.send(batteryValue_feed.key, str(batteryValue))
aio.send(batteryReserve_feed.key, str(batteryReserve))
aio.send(currentKWHRS_feed.key, str(availablePower))
aio.send(gridDraw_feed.key, str(gridUsage))
aio.send(chargingStatus_feed.key, str(chargingStatus))
aio.send(gridUseage_feed.key, str(gridUsage))
time.sleep(15)
except:
pass
await client.close()
def run(self):
# Setup Tesla API client
tclient = TeslaApiClient(self.email, self.password)
vehicles = tclient.list_vehicles()
# Currently, only one vehicle is supported. It would be nice to be
# able to click through multipe vehicles.
thisvehicle = vehicles[0]
display_name = thisvehicle.display_name
# If vehicle is offline, do not bother grabbing info
if thisvehicle.state != 'online':
self.output = {
"full_text": "%s: %s" % (display_name, thisvehicle.state),
"color": self.offline_color
}
else:
charge_info = vehicles[0].charge.get_state()
# Miles or meters?
if self.units != "miles":
battery_range = charge_info[
'battery_range'] * self.conversion_factor
charge_rate = charge_info[
'charge_rate'] * self.conversion_factor
else:
battery_range = charge_info['battery_range']
charge_rate = charge_info['charge_rate']
# Set colors for charging status
if charge_info['charging_state'] == 'Charging':
color = self.charging
charge_state_icon = self.charging_icon
else:
color = self.charge_complete
charge_state_icon = self.disconnect_icon
cdict = {
"name":
display_name,
"charge_state_icon":
charge_state_icon,
"battery_level":
charge_info['battery_level'],
"battery_range":
"%s %s" % (battery_range, self.units),
"battery_heater_on":
charge_info['battery_heater_on'],
"charge_current_request":
charge_info['charge_current_request'],
"charge_current_request_max":
charge_info['charge_current_request_max'],
"charge_enable_request":
charge_info['charge_enable_request'],
"charge_energy_added":
charge_info['charge_energy_added'],
"charge_limit_soc":
charge_info['charge_limit_soc'],
"charge_limit_soc_max":
charge_info['charge_limit_soc_max'],
"charge_limit_soc_min":
charge_info['charge_limit_soc_min'],
"charge_limit_soc_std":
charge_info['charge_limit_soc_std'],
"charge_miles_added_ideal":
charge_info['charge_miles_added_ideal'],
"charge_miles_added_rated":
charge_info['charge_miles_added_rated'],
"charge_port_cold_weather_mode":
charge_info['charge_port_cold_weather_mode'],
"charge_port_door_open":
charge_info['charge_port_door_open'],
"charge_port_latch":
charge_info['charge_port_latch'],
"charge_rate":
"%s%s/hr" % (charge_rate, self.units),
"charge_to_max_range":
charge_info['charge_to_max_range'],
"charger_actual_current":
charge_info['charger_actual_current'],
"charger_phases":
charge_info['charger_phases'],
"charger_pilot_current":
charge_info['charger_pilot_current'],
"charger_power":
charge_info['charger_power'],
"charger_voltage":
charge_info['charger_voltage'],
"charging_state":
charge_info['charging_state'],
"conn_charge_cable":
charge_info['conn_charge_cable'],
"est_battery_range":
charge_info['est_battery_range'],
"fast_charger_brand":
charge_info['fast_charger_brand'],
"fast_charger_present":
charge_info['fast_charger_present'],
"fast_charger_type":
charge_info['fast_charger_type'],
"ideal_battery_range":
charge_info['ideal_battery_range'],
"managed_charging_active":
charge_info['managed_charging_active'],
"managed_charging_start_time":
charge_info['managed_charging_start_time'],
"managed_charging_user_canceled":
charge_info['managed_charging_user_canceled'],
"max_range_charge_counter":
charge_info['max_range_charge_counter'],
"minutes_to_full_charge":
charge_info['minutes_to_full_charge'],
"not_enough_power_to_heat":
charge_info['not_enough_power_to_heat'],
"scheduled_charging_pending":
charge_info['scheduled_charging_pending'],
"scheduled_charging_start_time":
charge_info['scheduled_charging_start_time'],
"time_to_full_charge":
charge_info['time_to_full_charge'],
"timestamp":
charge_info['timestamp'],
"trip_charging":
charge_info['trip_charging'],
"usable_battery_level":
charge_info['usable_battery_level'],
"user_charge_enable_request":
charge_info['user_charge_enable_request']
}
if charge_info['charging_state'] == 'Charging':
self.output = {
"full_text": self.format_with_charge.format(**cdict),
"color": color
}
else:
self.output = {
"full_text": self.format_without_charge.format(**cdict),
"color": color
}
from tesla_api import TeslaApiClient
client = TeslaApiClient('MY-USERNAME', 'MY-PASSWORD')
energy_sites = client.list_energy_sites()
print("Number of energy sites = %d" % (len(energy_sites)))
assert (len(energy_sites) == 1)
print energy_sites[0]
energy_sites[0].set_operating_mode('autonomous')
import json
start = '1800'
finish = '16200'
settings = '{Content-Type: application/json}\n'
settings = '{"tou_settings":{"optimization_strategy": "economics", "schedule":['
settings = settings + '{"end_seconds": ' + finish + ', "week_days": [6, 0], "target": "off_peak", "start_seconds": ' + start + '},'
settings = settings + '{"end_seconds": ' + start + ', "week_days": [6, 0], "target": "peak", "start_seconds": ' + finish + '},'
settings = settings + '{"end_seconds": ' + finish + ', "week_days": [1, 2, 3, 4, 5], "target": "off_peak", "start_seconds": ' + start + '},'
settings = settings + '{"end_seconds": ' + start + ', "week_days": [1, 2, 3, 4, 5], "target": "peak", "start_seconds": ' + finish + '}]}}'
jsonsettings = json.loads(settings)
energy_sites[0].set_tou_settings(jsonsettings)
def client():
fake_client = TeslaApiClient("*****@*****.**", "fake_password")
return fake_client