def flash_firmware(hex_file,
part_id,
confirm=False,
check_only=True,
timeout=90):
"""
Flashes new SPM firmware to ATtiny.
"""
ret = {}
if not confirm:
raise salt.exceptions.CommandExecutionError(
"This command will flash firmware release '{:s}' onto the ATtiny - add parameter 'confirm=true' to continue anyway"
.format(hex_file))
# TODO: It is only possible to test flash an already installed version without getting verification errors from avrdude!
# Test flash firmware in read-only mode
#res = client.send_sync(_msg_pack(hex_file, no_write=True, _handler="flash_firmware"), timeout=timeout)
#ret["output"] = res.get("output", None)
# Flash firmware
if not check_only:
res = client.send_sync(_msg_pack(hex_file,
part_id,
no_write=False,
_handler="flash_firmware"),
timeout=timeout)
ret["output"] = res.get("output", None)
return ret
def query(cmd,
mode=None,
pid=None,
bytes=None,
decoder=None,
force=None,
**kwargs):
"""
Queries a given OBD command.
To see supported OBD commands for your vehicle run: obd.commands
Examples:
obd.query RPM
obd.query SPEED
obd.query FUEL_LEVEL force=True
obd.query custom_intake_temp_raw mode=01 pid=0F
obd.query custom_intake_temp mode=01 pid=0F decoder=temp
"""
return client.send_sync(
_msg_pack(cmd,
mode=mode,
pid=pid,
bytes=bytes,
decoder=decoder,
force=force,
**kwargs))
def manage(*args, **kwargs):
"""
Runtime management of the underlying service instance.
Supported commands:
- 'hook list|call <name> [argument]... [<key>=<value>]...'
- 'worker list|show|start|pause|resume|kill <name>'
- 'reactor list|show <name>'
- 'run <key>=<value>...'
Examples:
- 'obd.manage hook list'
- 'obd.manage hook call execute_handler ATRV'
- 'obd.manage worker list *'
- 'obd.manage worker show *'
- 'obd.manage worker start *'
- 'obd.manage worker pause *'
- 'obd.manage worker resume *'
- 'obd.manage worker kill *'
- 'obd.manage reactor list'
- 'obd.manage reactor show *'
- 'obd.manage run handler="query" args="[\"ELM_VOLTAGE\"]" converter="battery" returner="cloud"'
"""
return client.send_sync(_msg_pack(*args, _workflow="manage", **kwargs))
def send(msg, **kwargs):
"""
Sends a message on bus.
Arguments:
- msg (str): Message to send.
Optional arguments, general:
- header (str): Identifer of message to send. If none is specifed the default header will be used.
- auto_format (bool): Apply automatic formatting of messages? Default value is 'False'.
- expect_response (bool): Wait for response after sending? Avoid waiting for timeout by specifying the exact the number of frames expected. Default value is 'False'.
- raw_response (bool): Get raw response without any validation nor parsing? Default value is 'False'.
- echo (bool): Include the request message in the response? Default value is 'False'.
- protocol (str): ID of specific protocol to be used to receive the data. If none is specifed the current protocol will be used.
- baudrate (int): Specific protocol baudrate to be used. If none is specifed the current baudrate will be used.
- verify (bool): Verify that OBD-II communication is possible with the desired protocol? Default value is 'False'.
- output (str): What data type should the output be returned in? Default is a 'list'.
- type (str): Specify a name of the type of the result. Default is 'raw'.
Optional arguments, CAN specific:
- can_extended_address (str): Use CAN extended address.
- can_flow_control_clear (bool): Clear all CAN flow control filters and ID pairs before adding any new ones.
- can_flow_control_filter (str): Ensure CAN flow control filter is added. Value must consist of '<pattern>,<mask>'.
- can_flow_control_id_pair (str): Ensure CAN flow control ID pair is added. Value must consist of '<transmitter ID>,<receiver ID>'.
"""
return client.send_sync(_msg_pack(str(msg), _handler="send", **kwargs))
def manage(*args, **kwargs):
"""
Runtime management of the underlying service instance.
Supported commands:
- 'hook list|call <name> [argument]... [<key>=<value>]...'
- 'worker list|show|start|pause|resume|kill <name>'
- 'reactor list|show <name>'
- 'run <key>=<value>...'
Examples:
- 'cloud.manage hook list'
- 'cloud.manage hook call status_handler'
- 'cloud.manage worker list *'
- 'cloud.manage worker show *'
- 'cloud.manage worker start *'
- 'cloud.manage worker pause *'
- 'cloud.manage worker resume *'
- 'cloud.manage worker kill *'
- 'cloud.manage reactor list'
- 'cloud.manage reactor show *'
- 'cloud.manage run handler="cache" args="[\"list_queues\"]"'
"""
return client.send_sync(_msg_pack(*args, _workflow="manage", **kwargs))
def play(file, **kwargs):
"""
Plays all messages from a file on the bus.
Arguments:
- file (str): Path to file recorded with the 'obd.dump' command.
Optional arguments:
- delay (float): Delay in seconds between sending each message. Default value is '0'.
- slice (str): Slice the list of messages before sending on the CAN bus. Based one the divide and conquer algorithm. Multiple slice characters can be specified in continuation of each other.
- 't': Top half of remaining result.
- 'b': Bottom half of remaining result.
- filter (str): Filter out messages before sending on the CAN bus. Multiple filters can be specified if separated using comma characters.
- '+[id][#][data]': Include only messages matching string.
- '-[id][#][data]': Exclude messages matching string.
- '+duplicate': Include only messages where duplicates exist.
- '-duplicate': Exclude messages where duplicates exist.
- '+mutate': Include only messages where data mutates.
- '-mutate': Exclude messages where data mutates.
- group (str): How to group the result of sent messages. This only affects the display values returned from this command. Default value is 'id'.
- 'id': Group by message ID only.
- 'msg': Group by entire message string.
- protocol (str): ID of specific protocol to be used to send the data. If none is specifed the current protocol will be used.
- baudrate (int): Specific protocol baudrate to be used. If none is specifed the current baudrate will be used.
- verify (bool): Verify that OBD-II communication is possible with the desired protocol? Default value is 'False'.
- test (bool): Run command in test-only? (dry-run) mode. No data will be sent on CAN bus. Default value is 'False'.
"""
return client.send_sync(_msg_pack(file, _handler="play", **kwargs))
def query(cmd, mode=None, pid=None, bytes=None, decoder=None, force=None, **kwargs):
"""
Queries a given OBD command. To see supported OBD commands for your vehicle run: 'obd.commands'
Arguments:
- name (str): Name of the command.
Optional arguments:
- mode (str): Service section of the PID.
- pid (str): Code section of the PID.
- header (str): Identifer of message to send. If none is specifed the default OBD header will be used.
- bytes (int): Default value is '0'.
- decoder (str): Specific decoder to be used to process the response.
- formula (str): Formula written in Python to convert the response.
- unit (str): Unit of the result.
- protocol (str): ID of specific protocol to be used to receive the data. If none is specifed the current protocol will be used.
- baudrate (int): Specific protocol baudrate to be used. If none is specifed the current baudrate will be used.
- verify (bool): Verify that OBD-II communication is possible with the desired protocol? Default value is 'False'.
- force (bool): Force query of unknown command. Default is 'False'.
Examples:
- 'obd.query RPM'
- 'obd.query SPEED'
- 'obd.query FUEL_LEVEL force=True'
- 'obd.query custom_intake_temp_raw mode=01 pid=0F'
- 'obd.query custom_intake_temp mode=01 pid=0F decoder=temp'
"""
return client.send_sync(_msg_pack(cmd, mode=mode, pid=pid, bytes=bytes, decoder=decoder, force=force, **kwargs))
def power(cmd, **kwargs):
"""
Low-level function to run power command.
"""
return client.send_sync(_msg_pack(cmd, _handler="power", **kwargs),
timeout=60)
def download(cmd, size, dest, **kwargs):
"""
Low-level function to download files.
"""
return client.send_sync(
_msg_pack(cmd, size, dest, _handler="download", **kwargs))
def sync_time(force=False, **kwargs):
"""
Synchronize system time with network time.
"""
return client.send_sync(
_msg_pack(force=force, _handler="sync_time", **kwargs))
def query(cmd, cooldown_delay=None, **kwargs):
"""
Low-level function to execute AT commands.
"""
return client.send_sync(
_msg_pack(cmd, cooldown_delay=cooldown_delay, **kwargs))
def manage(*args, **kwargs):
"""
Runtime management of the underlying service instance.
Supported commands:
- 'hook list|call <name> [argument]... [<key>=<value>]...'
- 'worker list|show|start|pause|resume|kill <name>'
- 'reactor list|show <name>'
- 'run <key>=<value>...'
Examples:
- 'tracking.manage hook list'
- 'tracking.manage hook call gnss_query_handler location'
- 'tracking.manage worker list *'
- 'tracking.manage worker show *'
- 'tracking.manage worker start *'
- 'tracking.manage worker pause *'
- 'tracking.manage worker resume *'
- 'tracking.manage worker kill *'
- 'tracking.manage reactor list'
- 'tracking.manage reactor show *'
- 'tracking.manage run handler="gnss_query" args="[\"location\"]" converter="gnss_location_to_position" returner="cloud"'
"""
return client.send_sync(_msg_pack(*args, _workflow="manage", **kwargs))
def manage(*args, **kwargs):
"""
Examples:
- 'spm.manage handler' Lists all available handlers.
- 'spm.manage worker list *' Lists all existing worker threads.
"""
return client.send_sync(_msg_pack(*args, _workflow="manage", **kwargs))
def cache(cmd, *args, **kwargs):
"""
Queries/calls a given cache function.
"""
kwargs["_handler"] = "cache"
return client.send_sync(_msg_pack(cmd, *args, **kwargs))
def queue(audio_file):
"""
Queues an audio file.
Args:
audio_file (str):
"""
return client.send_sync(_msg_pack(audio_file, _handler="queue"))
def volume(value=None):
"""
Set volumen of the playback.
Optional arguments:
- value (int):
"""
return client.send_sync(_msg_pack(value=value, _handler="volume"))
def queue(audio_file):
"""
Queues an audio file.
Arguments:
- audio_file (str): Local path of audio file to play.
"""
return client.send_sync(_msg_pack(audio_file, _handler="queue"))
def speak(text, **kwargs):
"""
Speak given text.
Args:
text (str):
"""
return client.send_sync(_msg_pack(text, _handler="speak", **kwargs))
def query(cmd, *args, **kwargs):
"""
Queries a given SPM command.
Arguments:
- cmd (str): The SPM command to query.
"""
return client.send_sync(_msg_pack(cmd, *args, **kwargs))
def action(*args, **kwargs):
"""
Performs a key fob button action.
Arguments:
- *name (str): Name(s) of the action(s) to perform.
"""
return client.send_sync(_msg_pack(*args, _handler="action", **kwargs))
def power(**kwargs):
"""
Powers on/off key fob.
Optional arguments:
- value (bool): Power on or off.
"""
return client.send_sync(_msg_pack(_handler="power", **kwargs))
def speak(text, **kwargs):
"""
Speak given text.
Arguments:
- text (str): Text to speak out.
"""
return client.send_sync(_msg_pack(text, _handler="speak", **kwargs))
def led_pwm(**kwargs):
"""
Change PWM frequency and/or duty cycle for LED.
Optional arguments:
- frequency (float): Change to frequency in Hz.
- duty_cycle (float): Change to duty cycle in percent.
"""
return client.send_sync(_msg_pack(_handler="led_pwm", **kwargs))
def battery(**kwargs):
"""
Gets current battery voltage
"""
return client.send_sync(
_msg_pack("ELM_VOLTAGE",
protocol=None,
force=True,
_converter="battery",
**kwargs))
def _execute(cmd, **kwargs):
"""
Private helper function to execute commands.
"""
res = client.send_sync(_msg_pack(cmd, _handler="execute", **kwargs))
if not "value" in res and not "values" in res:
raise salt.exceptions.CommandExecutionError(
"Execution of command '{:s}' returned no value(s)".format(cmd))
return res
def play(audio_file, force=False, loops=0, volume=None):
"""
Plays a specific audio file.
Args:
audio_file (str):
force (bool):
loops (int):
volume (int):
"""
return client.send_sync(_msg_pack(audio_file, force=force, loops=loops, volume=volume, _handler="play"))
def setup(**kwargs):
"""
Setup advanced runtime settings.
Optional arguments:
- can_extended_address (str): Use CAN extended address.
- can_flow_control_clear (bool): Clear all CAN flow control filters and ID pairs before adding any new ones.
- can_flow_control_filter (str): Ensure CAN flow control filter is added. Value must consist of '<pattern>,<mask>'.
- can_flow_control_id_pair (str): Ensure CAN flow control ID pair is added. Value must consist of '<transmitter ID>,<receiver ID>'.
"""
return client.send_sync(_msg_pack(_handler="setup", **kwargs))
def connection(**kwargs):
"""
Manages current connection.
Optional arguments:
- close (bool): Close MMA8X5X connection? Default value is 'False'.
Examples:
- 'acc.connection'
- 'acc.connection close=True'
"""
return client.send_sync(_msg_pack(_handler="connection", **kwargs))
def dump(**kwargs):
"""
Dumps all messages from bus to screen or file.
Optional arguments:
- duration (int): How many seconds to record data? Default value is '2' seconds.
- file (str): Write data to a file with the given name.
- description (str): Additional description to the file.
- protocol (str): ID of specific protocol to be used to receive the data. If none is specifed the current protocol will be used.
- baudrate (int): Specific protocol baudrate to be used. If none is specifed the current baudrate will be used.
- verify (bool): Verify that OBD-II communication is possible with the desired protocol? Default value is 'False'.
"""
return client.send_sync(_msg_pack(_handler="dump", **kwargs))
def filter(action, **kwargs):
"""
Manages filters used when monitoring.
Arguments:
- action (str): Action to perform. Available actions are 'list', 'add' and 'clear'.
Examples:
- 'obd.filter list'
- 'obd.filter add type=<pass|block|flow> pattern=7C8 mask=7FF'
- 'obd.filter clear [type=<pass|block|flow>]'
"""
return client.send_sync(_msg_pack(action, _handler="filter", **kwargs))
