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