")
}
def setRefreshTime(String newRefreshTime)
{
if (debugLevel != "None") log.info "Refresh time currently set to: $refreshTime, overriding manually with $newRefreshTime"
sendEvent(name: "lastUpdate", value: now, descriptionText: "Last Update: $now")
sendEvent(name: "refreshTime", value: newrefreshTime)
if (newRefreshTime == "1-Hour")
{
unschedule(refresh)
runEvery1Hour(refresh)
device.updateSetting("refreshTime",[value:"1-Hour",type:"enum"])
}
else if (newRefreshTime == "30-Minutes")
{
unschedule(refresh)
runEvery30Minutes(refresh)
device.updateSetting("refreshTime",[value:"30-Minutes",type:"enum"])
}
else if (newRefreshTime == "15-Minutes")
{
unschedule(refresh)
runEvery15Minutes(refresh)
device.updateSetting("refreshTime",[value:"15-Minutes",type:"enum"])
}
else if (newRefreshTime == "10-Minutes")
{
unschedule(refresh)
runEvery10Minutes(refresh)
device.updateSetting("refreshTime",[value:"10-Minutes",type:"enum"])
}
else if (newRefreshTime == "5-Minutes")
{
unschedule(refresh)
runEvery5Minutes(refresh)
device.updateSetting("refreshTime",[value:"5-Minutes",type:"enum"])
}
else if (newRefreshTime == "1-Minute")
{
unschedule(refresh)
runEvery1Minute(refresh)
device.updateSetting("refreshTime",[value:"1-Minute",type:"enum"])
}
else if (newRefreshTime == "Disabled")
{
if (debugLevel != "None") log.info "Disabling..."
unschedule(refresh)
device.updateSetting("refreshTime",[value:"Disabled",type:"enum"])
}
else
{
log.warn "Unknown refresh time specified.. defaulting to 15 Minutes"
runEvery15Minutes(refresh)
device.updateSetting("refreshTime",[value:"15-Minutes",type:"enum"])
}
}
def getBatteryHealth()
{
if (debugLevel != "None") log.info "Executing 'getBatteryHealth'"
def data = parent.getBatteryHealth(device.currentValue('vin'))
processBatteryHealth(data)
}
private processBatteryHealth(data) {
// this returns a result list so make sure we have correct vin
if (data) {
if (debugLevel != "None") log.info "processbatteryHealthData: ${data}"
if (data.results)
{
if (debugLevel == "Full") log.debug "got battery result data = ${data}"
for (onecar in data)
{
def vin = onecar.vin
def cvin = device.currentValue('vin')
if (onecar?.vin)
{
if (debugLevel == "Full") log.debug "vin = $vin, cvin = $cvin"
if (vin == cvin)
{
def capacity = onecar.capacity
def originalCapacity = onecar.original_capacity
def degradation = onecar.degradation_percent
def health = onecar.health_percent
if (debugLevel == "Full") log.debug "health percent = $health %, capacity = $capacity, orig. capacity = $originalCapacity, degradation = $degradation %"
sendEvent(name: "batteryCapacity", value: capacity)
sendEvent(name: "batteryOriginalCapacity", value: originalCapacity)
sendEvent(name: "batteryDegradation", value: degradation)
sendEvent(name: "batteryHealth", value: health)
}
}
}
}
}
}
// lgk new web socket fleet api code
def toPSI()
{
def BigDecimal PSI = 14.503773773
return PSI
}
def processTimeToFullCharge2(perc)
{
def double minutestofc = perc * 60.0
def intmin = minutestofc.toInteger()
processTimeToFullCharge(intmin)
}
def processTimeToFullCharge(perc)
{
if (device.currentValue('chargingState') == "Charging")
{
if (perc != null )
{
def intmin = perc
def remain = 0
def hrs = 0
def hrsint = 0
// send minutes here are this is no longer coming through the websocket api
sendEvent(name: "minutes_to_full_charge", value: intmin)
if (intmin >= 60)
{
hrs = (intmin / 60)
hrsint = hrs.toInteger()
remain = (intmin - (hrsint * 60) ).toInteger()
}
else
{
hrsint = hrs.toInteger()
remain = intmin
}
// now create string
def timestring = ""
if (hrsint == 1)
{
timestring = "1 hour"
// now handle minutes
if (remain == 1)
{
timestring = timestring + " and 1 minute"
}
else if (remain > 0)
{
timestring = timestring + " and " + remain.toString() + " minutes"
}
}
else if (hrsint > 1)
{
timestring = hrsint.toString() + " hours"
if (remain == 1)
{
timestring = timestring + " and 1 minute"
}
else if (remain > 0)
{
timestring = timestring + " and " + remain.toString() + " minutes"
}
}
else if (hrsint == 0)
{
if (remain == 1)
{
timestring = timestring + "1 minute"
}
else if (remain > 0)
{
timestring = timestring + remain.toString() + " minutes"
}
}
// finish it off
timestring = timestring + " remaining to charge limit"
sendEvent(name: "timeToFullCharge", value: timestring)
}
} // we are charging
else
{
// not charge reset charge to time as for some reason the websocket still sends times here when the car is NOT charging but power is on say for conditioning.
sendEvent(name: "timeToFullCharge", value: "Not Charging")
}
}
def checkAltHomePresence(it) {
if (useAltPresence == true)
{
if (homeLongitude == null || homeLatitude == null)
{
log.error "Error: Home longitude or latitude is null and Alternate Presence method selected, Boundry Checking disabled!"
useAltPresence = false;
device.updateSetting("useAltPresence",[value:"false",type:"bool"])
}
else
{
def Float vehlat = it.value?.locationValue?.latitude?.toFloat()
def Float vehlong = it.value?.locationValue?.longitude?.toFloat()
def Float homelong = homeLongitude.toFloat() //-71.5996
def Float homelat = homeLatitude.toFloat() // 42.908368
if (debugLevel == "Full")
{
log.debug "current vehicle longitude,latitude = [ $vehlong, $vehlat ]"
log.debug "User set home longitude,latitude = [ $homelong, $homelat ]"
}
def Double dist = calculateDistanceBetweenTwoLatLongsInKm(vehlong, vehlat, homelong, homelat)
if (debugLevel != "None") log.info "Calculated distance from home: $dist"
if (dist <= boundryCircleDistance.toDouble())
{
if (device.currentValue('altPresent') == 'not present')
{
if (debugLevel != "None") log.info "Vehicle in range... setting presence to true"
sendEvent(name: "altPresent", value: "present")
sendEvent(name: "presence", value: "present")
}
}
else
{
if (device.currentValue('altPresent') == 'present')
{
if (debugLevel != "None") log.debug "Vehicle outside range... setting presence to false"
sendEvent(name: "altPresent", value: "not present")
sendEvent(name: "presence", value: "not present")
}
}
}
}
}
/* --------------------------- web socket fleet api code enhancements -------------------------------- */
def webSocketInit() {
// this gets called on a close or problem and spawns a new open, dont want a new open if we are disabled to sleep.
state.remove('webSocketOpenDelay')
webSocketOpen()
}
def webSocketClose() {
state.remove('webSocketTimestamp')
interfaces.webSocket.close()
}
def webSocketOpen() {
String tessieAccessToken = getParent()?.state?.tessieAccessToken ?: getParent()?.tessieAccessToken
String cvin = device.currentValue('vin')
if (tessieAccessToken && cvin && !state?.webSocketTimestamp)
{
try
{
interfaces.webSocket.connect("wss://streaming.tessie.com/${cvin}?access_token=${tessieAccessToken}")
if ((debugLevel != "None") || (debugWebSocketAPI)) "Websock opened!"
}
catch (Exception e)
{
log.error("${device.displayName} webSocketOpen() exception: $e")
}
}
else if(state?.webSocketTimestamp)
{
webSocketClose()
runIn(5,"webSocketOpen")
}
else
{
log.error "${device.displayName} webSocketOpen() could not start websocket vin:$cvin token:$tessieAccessToken"
}
}
def webSocketStatus(String message) {
// lgk dont do anything such as reopen if it is not enabled
if (useRealTimeAPI)
{
if ((debugLevel == "FULL") || (debugWebSocketAPI)) log.debug("${device.displayName} webSocketStatus $message${state?.webSocketTimestamp ? " after ${(now() - state?.webSocketTimestamp)/1000 as Integer} seconds" : ""}")
if (message?.contains("open"))
{
if ((debugLevel != "None" || (debugWebSocketAPI)) && state?.webSocketOpenDelay!=1) log.info "${device.displayName} websocket open"
state.webSocketTimestamp = now()
if (state?.currentVehicleState!="asleep")
{
runIn(2,refresh)
if ((debugLevel != "None") || (debugWebSocketAPI)) log.info "Scheduling refresh from Websocket API"
}
}
else if (state?.webSocketTimestamp)
{
// we had a good connection and now closing. but if open for less than one minute we had a problem. lets slow down next attempt. max ten minutes delay
// if disabled by time dont re-open
if (state.disabled != true)
{
state.webSocketOpenDelay = (now() - state.webSocketTimestamp > 60*1000) ? 1 : (state?.webSocketOpenDelay ? Math.min( state.webSocketOpenDelay * 2, 600 ) : 2)
if (state?.webSocketOpenDelay>2) log.warn "${device.displayName} delaying websocket retry by $state.webSocketOpenDelay seconds with reason: $message (short connection)"
webSocketClose()
runIn(state.webSocketOpenDelay,"webSocketOpen")
}
}
else
{
// we never had a good connection. lets slow down next attempt. max ten minutes delay
if (state.disabled != true)
{
state.webSocketOpenDelay = state?.webSocketOpenDelay ? Math.min( state.webSocketOpenDelay * 2, 600 ) : 2
if (state?.webSocketOpenDelay>2) log.warn "${device.displayName} delaying websocket retry by $state.webSocketOpenDelay seconds with reason: $message"
runIn(state.webSocketOpenDelay,"webSocketOpen")
}
}
}
}
def webSocketParse(String message) {
try {
def data = parseJson(message)
if (data?.data)
{
webSocketProcess(data.data)
}
else if (data?.alerts)
{
webSocketAlertsProcess(data.alerts)
}
else if (data?.errors)
{
webSocketErrorsProcess(data.errors)
}
else
{
if ((debugLevel == "FULL") || (debugWebSocketAPI)) log.debug("${device.displayName} webSocketParse() message: $data")
// if (state?.currentVehicleState=="asleep") runIn(2,refresh) // dont want refresh on every iteration.
}
}
catch (Exception e)
{
log.warn("${device.displayName} webSocketParse() exception ignored: $e message: $message")
}
}
// The api was changing, so not sure how long term these functions are needed. But for now, they work.
// [value:[stringValue:6.700000695884228], key:InsideTemp] but sometimes [value:[doubleValue:6.700000695884228], key:InsideTemp]
float getValueFloat(Map value) { return (value?.doubleValue ?: value?.stringValue ?: value?.intValue ?: 0.0).toFloat() }
float getValueTemp(Map value)
{
// lgk special case here celsius to fahrenheit not working when the value = 0 which is realy 32
def fval = getValueFloat(value)
//if (debugWebSocketAPI) log.debug " input = ${value.toString()} fval = ${value.toString()}"
if ((fval == 0.0) && (tempScale != "C")) return 32
else
{
def res = (tempScale == "C") ? getValueFloat(value) : celsiusToFahrenheit(getValueFloat(value))
//if (debugWebSocketAPI) log.debug "result = ${res.toFloat().toString()}"
return res.toFloat()
}
}
def handleInvalidSpeed(it)
{
// assume invalid means stopped to work around a bug in api missing the 0 case or interpretting it as null when we first stop
// if speed is invalid and we have a speed > 0 reset it
if (it.value?.invalid?.toBoolean() == true)
{
sendEventX(name: "speed", value: 0, unit: (mileageScale == "M") ? "mph" : "kph" );
sendEventX(name: "motion", value: "inactive")
}
else // set new websocket speed report state
{
if ((debugLevel != "None") && (state.haveWebSocketSpeedReport != "true")) // check so only get message once after startup
{
log.info "Have Telemetry data via WebSocket. Disabling Speed and Motion reports via legacy API."
}
state.haveWebSocketSpeedReport = "true"
}
}
float getValueMile(Map value) { return (mileageScale == "M") ? getValueFloat(value) : getValueFloat(value)*1.609344 }
Integer getValueInt(Map value) { return Math.round(getValueFloat(value)) as Integer}
Boolean getValueBool(Map value) { return (value?.stringValue ?: value?.booleanValue).toBoolean() }
void webSocketProcess(data) {
final Map handlers = [
"BatteryLevel": { it -> sendEventX(name: "battery", value: getValueInt(it?.value), unit: "%") }, // [value:[stringValue:80.68002108592515], key:BatteryLevel]
"SentryMode": { it -> sendEventX(name: "sentry_mode", value: it.value?.sentryModeStateValue=="SentryModeStateOff" ? "Off" : "On") }, // [value:[sentryModeStateValue:SentryModeStateOff], key:SentryMode]
"Locked": { it -> sendEventX(name: "lock", value: getValueBool(it?.value) ? "locked" : "unlocked") }, // [value:[stringValue:true], key:Locked]
"InsideTemp": { it -> sendEventX(name: "temperature", value: Math.round( getValueTemp(it?.value) ), unit: tempScale) }, // [value:[stringValue:6.700000695884228], key:InsideTemp] but sometimes [value:[doubleValue:6.700000695884228], key:InsideTemp]
"OutsideTemp": { it -> sendEventX(name: "outside_temperature", value: Math.round( getValueTemp(it?.value) ), unit: tempScale) }, // [value:[stringValue:4.5], key:OutsideTemp]
"TpmsHardWarnings": { it -> /* Handle TpmsHardWarnings */ },
"TpmsLastSeenPressureTimeFl": { it -> /* Handle TpmsLastSeenPressureTimeFl */ }, // [value:[stringValue:Sat Jan 11 13:31:17 2025], key:TpmsLastSeenPressureTimeFl]
"TpmsLastSeenPressureTimeFr": { it -> /* Handle TpmsLastSeenPressureTimeFr */ },
"TpmsLastSeenPressureTimeRl": { it -> /* Handle TpmsLastSeenPressureTimeRl */ },
"TpmsLastSeenPressureTimeRr": { it -> /* Handle TpmsLastSeenPressureTimeRr */ },
"TpmsPressureFl": { it -> sendEventX(name: "tire_pressure_front_left", value: (getValueFloat(it?.value) * toPSI()).round(1), unit: "psi") }, // [value:[stringValue:2.525000037625432], key:TpmsPressureFl]
"TpmsPressureFr": { it -> sendEventX(name: "tire_pressure_front_right", value: (getValueFloat(it?.value) * toPSI()).round(1), unit: "psi") },
"TpmsPressureRl": { it -> sendEventX(name: "tire_pressure_rear_left", value: (getValueFloat(it?.value) * toPSI()).round(1), unit: "psi") },
"TpmsPressureRr": { it -> sendEventX(name: "tire_pressure_rear_right", value: (getValueFloat(it?.value) * toPSI()).round(1), unit: "psi") },
"FdWindow": { it -> sendEventX(name: "front_drivers_window", value: it.value?.stringValue) }, // [value:[stringValue:Closed], key:FdWindow]
"FpWindow": { it -> sendEventX(name: "front_pass_window", value: it.value?.stringValue) },
"RdWindow": { it -> sendEventX(name: "rear_drivers_window", value: it.value?.stringValue) },
"RpWindow": { it -> sendEventX(name: "rear_pass_window", value: it.value?.stringValue) },
"SoftwareUpdateScheduledStartTime": { it -> /* Handle SoftwareUpdateScheduledStartTime */ },
"VehicleSpeed": { it -> Integer speed = Math.round(getValueMile(it?.value)); sendEventX(name: "speed", value: speed, unit: (mileageScale == "M") ? "mph" : "kph" ); sendEventX(name: "motion", value: speed>0 ? "active" : "inactive") }, // [value:[invalid:true], key:VehicleSpeed]
"ExpectedEnergyPercentAtTripArrival": { it -> sendEventX(name: "active_route_energy_at_arrival", value: getValueInt(it?.value)) },
"MilesToArrival": { it -> sendEventX(name: "active_route_miles_to_arrival", value: getValueMile(it?.value).round(1), unit: mileageScale ) }, // [value:[doubleValue:1.4336150427289294], key:MilesToArrival]
"MinutesToArrival": { it -> sendEventX(name: "active_route_minutes_to_arrival", value: getValueFloat(it?.value).round(2), unit: "min" ) }, // [value:[doubleValue:7], key:MinutesToArrival]
"Gear": { it -> /* Handle Gear */ }, // [value:[shiftStateValue:ShiftStateP], key:Gear], [value:[shiftStateValue:ShiftStateD], key:Gear], [value:[shiftStateValue:ShiftStateR], key:Gear]
"ClimateKeeperMode": { it -> /* Handle ClimateKeeperMode */ },
"ScheduledChargingStartTime": { it -> /* Handle ScheduledChargingStartTime */ },
"SeatHeaterLeft": { it -> sendEventX(name: "seat_heater_left", value: getValueInt(it?.value)) }, // [value:[stringValue:0], key:SeatHeaterLeft]
"SeatHeaterRight": { it -> sendEventX(name: "seat_heater_right", value: getValueInt(it?.value)) },
"SeatHeaterRearLeft": { it -> sendEventX(name: "seat_heater_rear_left", value: getValueInt(it?.value)) },
"SeatHeaterRearCenter": { it -> sendEventX(name: "seat_heater_rear_center", value: getValueInt(it?.value)) },
"SeatHeaterRearRight": { it -> sendEventX(name: "seat_heater_rear_right", value: getValueInt(it?.value)) },
"HvacSteeringWheelHeatAuto": { it -> /* Handle HvacSteeringWheelHeatAuto */ },
"HvacLeftTemperatureRequest": { it -> sendEventX(name: "thermostatSetpoint", value: Math.round( getValueTemp(it?.value) ), unit: tempScale) }, // [value:[doubleValue:20.5], key:HvacLeftTemperatureRequest]
"HvacRightTemperatureRequest": { it -> sendEventX(name: "passengerSetpoint", value: Math.round( getValueTemp(it?.value) ), unit: tempScale) },
"HvacPower": { it -> sendEventX(name: "thermostatMode", value: it.value?.hvacPowerValue=="HvacPowerStateOff" ? "off" : "auto") }, // [value:[hvacPowerValue:HvacPowerStateOn], key:HvacPower], [value:[hvacPowerValue:HvacPowerStateOff], key:HvacPower]
"AutoSeatClimateLeft": { it -> /* Handle AutoSeatClimateLeft */ },
"AutoSeatClimateRight": { it -> /* Handle AutoSeatClimateRight */ },
"RouteTrafficMinutesDelay": { it -> /* Handle RouteTrafficMinutesDelay */ },
"BatteryHeaterOn": { it -> /* Handle BatteryHeaterOn */ },
"CurrentLimitMph": { it -> /* Handle CurrentLimitMph */ },
"RatedRange": { it -> sendEventX(name: "batteryRange", value: Math.round( getValueMile(it?.value) ), unit: mileageScale ) }, // [value:[stringValue:225.9622591002932], key:RatedRange]
"RemoteStartEnabled": { it -> /* Handle RemoteStartEnabled */ },
"SoftwareUpdateVersion": { it -> /* Handle SoftwareUpdateVersion */ },
"Odometer": { it -> sendEventX(name: "odometer", value: getValueMile(it?.value).toInteger(), unit: mileageScale ) }, // [value:[stringValue:3379.656716239699], key:Odometer]
"DefrostMode": { it -> /* Handle DefrostMode */ },
"ScheduledChargingPending": { it -> /* Handle ScheduledChargingPending */ },
"VehicleName": { it -> /* Handle VehicleName */ },
"CabinOverheatProtectionMode": { it -> /* Handle CabinOverheatProtectionMode */ },
"ACChargingPower": { it -> /* Handle ACChargingPower */ },
"EnergyRemaining": { it -> /* Handle EnergyRemaining */ },
"DestinationLocation": { it -> /* Handle DestinationLocation */ },
"PackCurrent": { it -> /* Handle PackCurrent */ },
"CabinOverheatProtectionTemperatureLimit": { it -> /* Handle CabinOverheatProtectionTemperatureLimit */ },
"ModuleTempMin": { it -> /* Handle ModuleTempMin */ },
"SoftwareUpdateExpectedDurationMinutes": { it -> /* Handle SoftwareUpdateExpectedDurationMinutes */ },
"SoftwareUpdateInstallationPercentComplete": { it -> /* Handle SoftwareUpdateInstallationPercentComplete */ },
"PackVoltage": { it -> /* Handle PackVoltage */ },
"GuestModeEnabled": { it -> /* Handle GuestModeEnabled */ },
"ValetModeEnabled": { it -> sendEventX(name: "valet_mode", value: getValueBool(it?.value) ? "On" : "Off") }, // [value:[booleanValue:false], key:ValetModeEnabled]
"GpsHeading": { it -> sendEventX(name: "heading", value: getValueInt(it?.value), unit: "°") }, // [value:[stringValue:63.3255034690718], key:GpsHeading]
"LifetimeEnergyUsed": { it -> /* Handle LifetimeEnergyUsed */ },
"DCChargingPower": { it -> /* Handle DCChargingPower */ },
"Location": { it -> checkAltHomePresence(it); sendEventX(name: "latitude", value: it.value?.locationValue?.latitude?.toFloat(), unit: "°"); sendEventX(name: "longitude", value: it.value?.locationValue?.longitude?.toFloat(), unit: "°"); }, // [value:[locationValue:[latitude:41.040694, longitude:-73.540426]], key:Location]
"Soc": { it -> /* Handle Soc */ },
"Version": { it -> /* Handle Version */ },
"SpeedLimitMode": { it -> /* Handle SpeedLimitMode */ }, // [value:[stringValue:false], key:SpeedLimitMode]
"ScheduledChargingMode": { it -> /* Handle ScheduledChargingMode */ }, // [value:[stringValue:Off], key:ScheduledChargingMode]
"ModuleTempMax": { it -> /* Handle ModuleTempMax */ }, // [value:[stringValue:5], key:ModuleTempMax]
"SoftwareUpdateDownloadPercentComplete": { it -> /* Handle SoftwareUpdateDownloadPercentComplete */ }, // [value:[intValue:0], key:SoftwareUpdateDownloadPercentComplete]
"HomelinkNearby": { it -> if (useAltPresence != true) { sendEventX(name: "presence", value: getValueBool(it?.value) ? "present" : "not present") }/* Handle HomelinkNearby */ }, // [value:[booleanValue:false], key:HomelinkNearby]
"ChargeAmps": { it -> sendEventX(name: "current_charge_amps", value: getValueInt(it?.value)) },
"ChargeLimitSoc": { it -> sendEventX(name: "current_charge_limit", value: getValueInt(it?.value)) },
"ChargeCurrentRequestMax": { it -> /* Handle ChargeCurrentRequestMax */ },
"ChargeCurrentRequest": { it -> /* Handle ChargeCurrentRequest */ },
"ChargePortLatch": { it -> /* Handle ChargePortLatch */ },
"ChargePortDoorOpen": { it -> /* Handle ChargePortDoorOpen */ },
"FastChargerPresent": { it -> /* Handle FastChargerPresent */ }, // [value:[stringValue:false], key:FastChargerPresent]
"FastChargerType": { it -> /* Handle FastChargerType */ },
"DetailedChargeState": { it -> /* Handle DetailedChargeState */ },
"TimeToFullCharge": { it -> processTimeToFullCharge2(getValueFloat(it?.value)) /* Handle TimeToFullCharge */ }, // this is minutes in decimal percentage of an hour so multiple by 60.
"PinToDriveEnabled": { it -> /* Handle PinToDriveEnabled */ }, // [value:[stringValue:false], key:PinToDriveEnabled]
"DriverSeatOccupied": { it -> sendEventX(name: "user_present", value: getValueBool(it?.value)) }, // [value:[booleanValue:false], key:DriverSeatOccupied]
"DestinationName": { it -> sendEventX(name: "active_route_destination", value: it?.value?.stringValue) }, // [value:[stringValue:Home], key:DestinationName]
"ChargerPhases": { it -> /* Handle ChargerPhases */ }, // [value:[intValue:1], key:ChargerPhases]
"DoorState": { it -> // [value:[doorValue:[DriverRear:false, PassengerFront:false, TrunkFront:false, PassengerRear:false, TrunkRear:false, DriverFront:false]], key:DoorState] was [value:[stringValue:DriverFront|PassengerFront|DriverRear|PassengerRear|TrunkFront|TrunkRear], key:DoorState] or [value:[stringValue:], key:DoorState]
sendEventX(name: "front_drivers_door", value: it.value?.doorValue?.DriverFront?.toBoolean() ? "Open" : "Closed")
sendEventX(name: "front_pass_door", value: it.value?.doorValue?.PassengerFront?.toBoolean() ? "Open" : "Closed")
sendEventX(name: "rear_drivers_door", value: it.value?.doorValue?.DriverRear?.toBoolean() ? "Open" : "Closed")
sendEventX(name: "rear_pass_door", value: it.value?.doorValue?.PassengerRear?.toBoolean() ? "Open" : "Closed")
sendEventX(name: "frunk", value: it.value?.doorValue?.TrunkFront?.toBoolean() ? "Open" : "Closed")
sendEventX(name: "trunk", value: it.value?.doorValue?.TrunkRear?.toBoolean() ? "Open" : "Closed")
},
]
if ((debugLevel == "FULL") || (debugWebSocketAPI))
log.debug "full Websocket fleet api data = $data"
data?.each
{
if ((debugLevel == "FULL") || (debugWebSocketAPI)) log.debug "in handler item = $it"
// special case spped invalid
//log.warn "key = ${it.key}"
if (it.key == "VehicleSpeed")
{
handleInvalidSpeed(it)
}
if (it?.value==null || it.value?.invalid?.toBoolean()!=true)
{ // toss any invalid data first
if ((handlers.get(it.key, {
if (debugLevel == "Full") log.info("${device.displayName} webSocketProcess() did not handle item: $it")
return true
})(it)) != true) {
if (debugLevel == "Full") log.info("${device.displayName} webSocketProcess() did not process item: $it")
}
}
}
if (data != null)
{
def now = new Date().format('MM/dd/yyyy h:mm a',location.timeZone)
sendEvent(name: "lastUpdate", value: now, descriptionText: "Last Update: $now")
//if (debugLevel != "None") log.info "WebsocketAPI: processing data!"
}
}
/*
{
"errors": [
{
"createdAt": "2024-08-01T00:44:06.780721459Z",
"name": "unsupported_field",
"tags": {
"field_name": "LifetimeEnergyGainedRegen",
"name": "1bfd3e4b3966-496c-b87a-59999f71234"
},
"body": ""
}
],
"createdAt": "2024-08-01T00:44:06.780721459Z",
"vin": "LRW3F7FR9NC123456"
}
*/
void webSocketErrorsProcess(data)
{
if ((debugLevel == "FULL") || (debugWebSocketAPI))
{
log.warn "Processing Websocket Error message."
log.warn "Error data = $data"
}
def ctr = 0
data?.each
{
if (ctr == 0)
{
++ctr
def name = it.name
def timestamp = it.createdAt
sendEvent(name: "lastWebSocketError", value: name, description: "WebSocketError [$name, $timestamp] {$it)!")
log.warn "WebSocketError [$name, $timestamp]!"
}
}
if (ctr == 0) device.deleteCurrentState('lastWebSocketError')
}
void webSocketAlertsProcess(data)
{
if ((debugLevel == "FULL") || (debugWebSocketAPI))
{
log.info "Processing Firmware Alert Data (websocket version)."
log.info "Alert data = $data"
}
def ctr = 0
data?.each
{
if (ctr == 0)
{
++ctr
def name = it.name
def startedAt = it.startedAt
def endedAt = it.endedAt
def alertTime = ""
if (startedAt != null) alertTime = startedAt
else if (endedAt != null) alertTime = endedAt
else log.warn "No timedate (startedAt/endedAt) for last firmware Alert (${it})!"
if (alertTime != "")
{
// convert utc alert time to localtime
Instant instant = Instant.parse(alertTime);
LocalDateTime ldt = instant.atZone(ZoneId.of(location.timeZone.ID)).toLocalDateTime();
DateTimeFormatter dTF = DateTimeFormatter.ofPattern("MM/dd/yyyy h:mm:ss a");
def formateddate = dTF.format(ldt)
if (device.currentValue("lastFirmwareAlertTime") != formateddate)
{
sendEvent(name: "lastFirmwareAlert", value: name)
sendEvent(name: "lastFirmwareAlertTime", value: formateddate)
if ((debugLevel != "None") || (debugWebSocketAPI)) log.warn "Got a firmware alert from WebSocket API: [$name, $formateddate]!"
// now since we got a real time firmware alert call the api call to update all of them
if (enableFirmwareAlerts) getFirmwareAlerts()
}
else if (debugLevel == "Full") log.info "Ignoring duplicate firmware alert!"
}
}
}
}
Boolean sendEventX(Map x)
{
if ((debugLevel == "Full") || (debugWebSocketAPI)) log.debug "in sendeventx:[ ${x?.name}, ${x?.value} prior: ${device.currentValue(x?.name).toString().toLowerCase()} ]"
if (x?.value!=null && device.currentValue(x?.name).toString().toLowerCase() != x?.value.toString().toLowerCase() && !x?.eventDisable)
{
if ((debugLevel == "Full") || (debugWebSocketAPI)) log.debug("new value will be set")
x.descriptionText = x.descriptionText ?: "${device.displayName} ${x.name.replace('_', ' ')} is $x.value${x?.unit?:""}"
if (x?.logLevel=="warn") log.warn (x?.descriptionText); else if (debugLevel == "Full") log.info (x?.descriptionText)
sendEvent(name: x?.name, value: x?.value, unit: x?.unit, descriptionText: x?.descriptionText, isStateChange: (x?.isStateChange ?: false))
}
return true
}