tesla-api 0.0.1

data/lib/tesla-api.rb

@@ -0,0 +1,16 @@
+require 'json'
+require 'httpclient'
+
+require "tesla-api/tesla_api"
+require "tesla-api/version"
+require "tesla-api/data"
+require "tesla-api/private_api"
+require "tesla-api/connection"
+require "tesla-api/charge_state"
+require "tesla-api/climate_state"
+require "tesla-api/drive_state"
+require "tesla-api/errors"
+require "tesla-api/gui_settings"
+require "tesla-api/vehicle"
+require "tesla-api/vehicle_state"
+

data/lib/tesla-api/charge_state.rb

@@ -0,0 +1,87 @@
+module TeslaAPI
+
+  # Defines the current charge state of the vehicle
+  class ChargeState < Data
+    ##
+    # :method: charging_state
+    # Charging state ("Complete", "Charging")
+
+    ##
+    # :method charging_to_max?
+    # true if currently performing a range charge
+
+    ##
+    # :method: battery_range_miles
+    # Rated miles for the current charge
+
+    ##
+    # :method: estimated_battry_range_miles
+    # Range estimated from current driving
+
+    ##
+    # :method: ideal_battery_range_miles
+    # Ideal range for the current charge
+
+    ##
+    # :method: battery_percentage
+    # Percentage of battery charge
+
+    ##
+    # :method: battery_current_flow
+    # Current flowing into the battery
+
+    ##
+    # :method: charger_voltage
+    # Current voltage being used to charge battery
+
+    ##
+    # :method: charger_pilot_amperage
+    # Max amperage allowed by the charger
+
+    ##
+    # :method: charger_actual_amperage
+    # Current amperage being drawn into battery
+
+    ##
+    # :method: charger_power
+    # Kilowatt of charger (rounded down)
+
+    ##
+    # :method: hours_to_full_charge
+    # Hours remaining until the vehicle is fully charged
+
+    ##
+    # :method: charge_rate_miles_per_hour
+    # Miles of range being added per hour
+
+    ##
+    # :method: charge_port_open?
+    # true if the charge port is open
+
+    ##
+    # :method: supercharging?
+    # true if charging via a Tesla SuperCharger
+
+    def initialize(data) # :nodoc:
+      ivar_from_data("charging_state",               "charging_state",         data)
+      ivar_from_data("charging_to_max",              "charge_to_max_range",    data)
+      ivar_from_data("battery_range_miles",          "battery_range",          data)
+      ivar_from_data("estimated_battry_range_miles", "est_battery_range",      data)
+      ivar_from_data("ideal_battery_range_miles",    "ideal_battery_range",    data)
+      ivar_from_data("battery_percentage",           "battery_level",          data)
+      ivar_from_data("battery_current_flow",         "battery_current",        data)
+      ivar_from_data("charger_voltage",              "charger_voltage",        data)
+      ivar_from_data("charger_pilot_amperage",       "charger_pilot_current",  data)
+      ivar_from_data("charger_actual_amperage",      "charger_actual_current", data)
+      ivar_from_data("charger_power",                "charger_power",          data)
+      ivar_from_data("hours_to_full_charge",         "time_to_full_charge",    data)
+      ivar_from_data("charge_rate_miles_per_hour",   "charge_rate",            data)
+      ivar_from_data("charge_port_open",             "charge_port_door_open",  data)
+      ivar_from_data("supercharging",                "fast_charger_present",   data)
+
+      @charging        = charging_state == "Charging"
+      @charge_complete = charging_state == "Complete"
+    end
+  end
+end
+

data/lib/tesla-api/climate_state.rb

@@ -0,0 +1,55 @@
+module TeslaAPI
+  # Defines the climate state of the vehicle.
+  #
+  class ClimateState < Data
+    ##
+    # :method: inside_temp_celcius
+    # Temperature (celcius) inside the vehicle
+
+    ##
+    # :method: outside_temp_celcius
+    # Temperature (celcius) outside the vehicle
+
+    ##
+    # :method: driver_temp_setting_celcius
+    # Temperature (celcius) the driver has set
+
+    ##
+    # :method: passenger_temp_setting_celcius
+    # Temperature (celcius) the passenger has set
+
+    ##
+    # :method: fan_speed
+    # 0 to 6 (or nil)
+
+    ##
+    # :method: auto_conditioning_on?
+    # true if auto air conditioning is on
+
+    ##
+    # :method: front_defroster_on?
+    # true if the front defroster is on
+
+    ##
+    # :method: rear_defroster_on?
+    # true if the rear defroster is on
+
+    ##
+    # :method: fan_on?
+    # true if the fan is on
+
+    def initialize(data) # :nodoc:
+      ivar_from_data("inside_temp_celcius",            "inside_temp",            data)
+      ivar_from_data("outside_temp_celcius",           "outside_temp",           data)
+      ivar_from_data("driver_temp_setting_celcius",    "driver_temp_setting",    data)
+      ivar_from_data("passenger_temp_setting_celcius", "passenger_temp_setting", data)
+      ivar_from_data("fan_speed",                      "fan_speed",              data)
+
+      @auto_conditioning_on   = !!data["is_auto_conditioning_on"]
+      @front_defroster_on     = !!data["is_front_defroster_on"]
+      @rear_defroster_on      = !!data["is_rear_defroster_on"]
+      @fan_on                 = !data["fan_status"].nil?
+    end
+  end
+end
+

data/lib/tesla-api/connection.rb

@@ -0,0 +1,58 @@
+module TeslaAPI
+  # Connection object to the Tesla Model S HTTP API endpoint.
+  class Connection
+    include PrivateAPI
+
+    # email address of logged in user
+    attr_reader :email
+
+    # password of logged in user
+    attr_reader :password
+
+    # Host for status/command related API
+    HOST = "https://portal.vn.teslamotors.com"
+
+    # Host for streaming API
+    STREAMING_HOST = "https://streaming.vn.teslamotors.com"
+
+    # Supply the email and password for login to teslamotors.com
+    def initialize(email, password)
+      @email    = email
+      @password = password
+
+      @client = HTTPClient.new
+      @client.set_cookie_store("cookie.dat")
+
+      login(email, password)
+    end
+
+    # Call to see all HTTP traffic to and from the API
+    def debug!
+      @client.debug_dev = STDOUT
+    end
+
+    # Convenience method to return the first Vehicle
+    def vehicle
+      vehicles.first
+    end
+
+    # Returns Vehicle objects for all vehicles the account contains
+    def vehicles
+      @vehicles ||= begin
+        _, json = get_json("/vehicles")
+        json.map { |data| Vehicle.new(self, data) }
+      end
+    end
+
+    # Force the vehicles to reload (in case some of the data has changed)
+    def reload!
+      @vehicles = nil
+    end
+
+    # Logged into the API
+    def logged_in?
+      @logged_in
+    end
+  end
+end
+

data/lib/tesla-api/data.rb

@@ -0,0 +1,52 @@
+module TeslaAPI
+  # Base class for all data responses from the HTTP API
+  #
+  # Defines an instance_variable? method for each instance_variable defined allowing for
+  # methods such as __________?
+  #
+  # Also overrides #inspect to elimiante the back reference to the connection object
+  class Data
+    def method_missing(method_name, *args, &block) # :nodoc:
+      if has_query_ivar_method?(method_name)
+        instance_variable_get(ivar_for_method_name(method_name))
+      else
+        super(symbol, *args, &block)
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false) # :nodoc:
+      has_query_ivar_method?(method_name) || super
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class.name}:0x#{self.object_id.to_s(16)} #{inspect_ivars}>"
+    end
+
+    def ivar_from_data(name, data_key, data) # :nodoc:
+      instance_variable_set("@#{name}".to_sym, data[data_key])
+
+      self.class.send(:attr_reader, name.to_sym)
+    end
+
+    protected
+
+    def ivar_for_method_name(method_name) # :nodoc:
+      "@#{method_name.to_s.gsub(/\?$/,"")}".to_sym
+    end
+
+    def has_query_ivar_method?(method_name) # :nodoc:
+      method = method_name.to_s
+
+      method =~ /(.+)\?/ && instance_variables.include?(ivar_for_method_name(method_name))
+    end
+
+    def inspect_ivars # :nodoc:
+      ivars_for_inspect.map { |ivar| "#{ivar}=#{instance_variable_get(ivar)}" }.join(" ")
+    end
+
+    def ivars_for_inspect # :nodoc:
+      (instance_variables - [:@tesla])
+    end
+  end
+end
+

data/lib/tesla-api/drive_state.rb

@@ -0,0 +1,37 @@
+module TeslaAPI
+  # Data defining the driving state of the the vehicle
+  class DriveState < Data
+    # Time when GPS data was recorded
+    attr_reader :gps_timestamp
+
+    ##
+    # :method: shift_state
+    # Unknown
+
+    ##
+    # :method: speed
+    # Vehicle speed (units?)
+
+    ##
+    # :method: latitude
+    # Lattitude of vehicle
+
+    ##
+    # :method: longitude
+    # Longitude of vehicle
+
+    ##
+    # :method: heading
+    # Compass heading (0 to 360) degrees
+
+    def initialize(data) # :nodoc:
+      ivar_from_data("shift_state", "shift_state", data)
+      ivar_from_data("speed",       "speed",       data)
+      ivar_from_data("latitude",    "latitude",    data)
+      ivar_from_data("longitude",   "longitude",   data)
+      ivar_from_data("heading",     "heading",     data)
+      @gps_timestamp = Time.at(data["gps_as_of"])
+    end
+  end
+end
+

data/lib/tesla-api/errors.rb

@@ -0,0 +1,41 @@
+module TeslaAPI
+  # Exceptions thrown by the TeslaAPI
+  module Errors
+    # JSON cannot be parsed
+    class InvalidJSON < StandardError
+      # JSON parsing error details
+      attr_reader :error
+
+      def initialize(error) # :nodoc:
+        @error = error
+      end
+
+      def to_s # :nodoc:
+        error.to_s
+      end
+    end
+
+    # Thrown when the action requires a logged in connection
+    class NotLoggedIn < StandardError
+    end
+
+    # Thrown when the API returns a failure state
+    class APIFailure < StandardError
+    end
+
+    # Thrown when the response is invalid (non 200-OK HTTP result)
+    class InvalidResponse < StandardError
+      # Response object from httpclient
+      attr_reader :response
+
+      def initialize(response) # :nodoc:
+        @response = response
+      end
+
+      def to_s # :nodoc:
+        "Invalid Response: #{response.inspect}"
+      end
+    end
+  end
+end
+

data/lib/tesla-api/gui_settings.rb

@@ -0,0 +1,34 @@
+module TeslaAPI
+  # Defines the current user settings for the vehicle's graphical display
+  class GUISettings < Data
+    ##
+    # :method: gui_distance_units
+    # Units ("mi/hr") for showing range
+
+    ##
+    # :method: gui_temperature_units
+    # Units ("F", "C") for showing temperaturs
+
+    ##
+    # :method: gui_charge_rate_units
+    # Units ("kW") for showing charge rage
+
+    ##
+    # :method: gui_range_display
+    # Units ("Rated", "Ideal") for showing range
+
+    # true if the UI show 24 hour time (e.g. 17:45)
+    def gui_24_hour_time?
+      @gui_24_hour_time
+    end
+
+    def initialize(data) # :nodoc:
+      ivar_from_data("gui_distance_units",    "gui_distance_units",    data)
+      ivar_from_data("gui_temperature_units", "gui_temperature_units", data)
+      ivar_from_data("gui_charge_rate_units", "gui_charge_rate_units", data)
+      ivar_from_data("gui_24_hour_time",      "gui_24_hour_time",      data)
+      ivar_from_data("gui_range_display",     "gui_range_display",     data)
+    end
+  end
+end
+

data/lib/tesla-api/private_api.rb

@@ -0,0 +1,157 @@
+module TeslaAPI
+  module PrivateAPI # :nodoc:
+    def login(email, password)
+      params = { "user_session[email]"    => email,
+                 "user_session[password]" => password }
+
+      response = @client.post(Connection::HOST + "/login", params)
+
+      @logged_in = (response.status_code == HTTP::Status::FOUND)
+    end
+
+    def stream(vehicle)
+      raise "Doesn't work yet"
+
+      client = HTTPClient.new
+
+      uri = Connection::STREAMING_HOST + "/stream/#{vehicle.vehicle_id}/?values=speed,odometer,soc,elevation,est_heading,est_lat,est_lng,power,shift_state"
+
+      client.set_basic_auth(uri, streaming_login, vehicle.tokens.first)
+      client.get_content(uri) do |chunk|
+        p chunk
+      end
+    end
+
+    def set_temperature!(vehicle, driver_degrees_celcius, passenger_degrees_celcius)
+      command!(vehicle, "set_temps", :query => { :driver_degrees_celcius    => driver_degrees_celcius,
+                                                 :passenger_degrees_celcius => passenger_degrees_celcius })
+    end
+
+    def open_roof!(vehicle, state)
+      command!(vehicle, "sun_roof_control", :query => { :state => state })
+    end
+
+    def auto_conditioning_stop!(vehicle)
+      command!(vehicle, "auto_conditioning_stop")
+    end
+
+    def auto_conditioning_start!(vehicle)
+      command!(vehicle, "auto_conditioning_start")
+    end
+
+    def lock_door!(vehicle)
+      command!(vehicle, "door_lock")
+    end
+
+    def unlock_door!(vehicle)
+      command!(vehicle, "door_unlock")
+    end
+
+    def honk_horn!(vehicle)
+      command!(vehicle, "honk_horn")
+    end
+
+    def flash_lights!(vehicle)
+      command!(vehicle, "flash_lights")
+    end
+
+    def charge_stop!(vehicle)
+      command!(vehicle, "charge_stop")
+    end
+
+    def charge_start!(vehicle)
+      command!(vehicle, "charge_start")
+    end
+
+    def charge_max_range!(vehicle)
+      command!(vehicle, "charge_max_range")
+    end
+
+    def charge_standard!(vehicle)
+      command!(vehicle, "charge_standard")
+    end
+
+    def wake_up!(vehicle)
+      command!(vehicle, "wake_up")
+    end
+
+    def open_charge_port!(vehicle)
+      command!(vehicle, "charge_port_open")
+    end
+
+    def api_mobile_access?(vehicle)
+      _, json = get_json(command_url(vehicle, "mobile_enabled"))
+
+      json["result"] == true
+    end
+
+    def api_get_vehicle_state_for_vehicle(vehicle)
+      _, json = get_json(command_url(vehicle, "vehicle_state"))
+
+      VehicleState.new(json)
+    end
+
+    def api_gui_settings_for_vehicle(vehicle)
+      _, json = get_json(command_url(vehicle, "gui_settings"))
+
+      GUISettings.new(json)
+    end
+
+    def api_drive_state_for_vehicle(vehicle)
+      _, json = get_json(command_url(vehicle, "drive_state"))
+
+      DriveState.new(json)
+    end
+
+    def api_climate_state_for_vehicle(vehicle)
+      _, json = get_json(command_url(vehicle, "climate_state"))
+
+      ClimateState.new(json)
+    end
+
+    def api_charge_state_for_vehicle(vehicle)
+      _, json = get_json(command_url(vehicle, "charge_state"))
+
+      ChargeState.new(json)
+    end
+
+    private
+
+    def streaming_login
+      email.gsub("@","%")
+    end
+
+    def check_logged_in!
+      raise Errors::NotLoggedIn unless logged_in?
+    end
+
+    def command_url(vehicle, command_name)
+      "/vehicles/#{vehicle.id}/command/#{command_name}"
+    end
+
+    def command!(vehicle, command_name, options = {})
+      _, json = get_json(command_url(vehicle, command_name), options)
+
+      json["result"] ? json["result"] : raise(Errors::APIFailure.new(json["reason"]))
+    end
+
+    def get_json(uri, options = {})
+      check_logged_in!
+
+      response = get(uri, options)
+
+      [response, JSON.parse(response.body)]
+    rescue JSON::ParserError => e
+      raise Errors::InvalidJSON.new(e)
+    end
+
+    def get(uri, options = {})
+      response = @client.get(Connection::HOST + uri, options)
+
+      raise Errors::InvalidResponse.new(response) unless response.status_code == HTTP::Status::OK
+
+      response
+    end
+  end
+end
+