remote control for your car - comma_hack 5
February 27th, 2025
Over the weekend, I attended COMMA_HACK 5, comma.ai's first car hackathon. My goal going into this was to integrate remote control car commands into their existing web app called connect.
Currently a lot of cars have their own app that allows you to control things such as HVAC, ignition, and lights. However I've found it to be very slow and not reliable. My 2023 hyundai sonata has their own called BlueLink and I've just stopped using it after so many failed attempts.
Sending signals from web app <-> car
The first step to sending signals from web app <-> car was to include a new dispatch method service within the existing athenad.py file. I added a custom remote command handler that could process control signals sent from the web interface.
Here's the key part of the implementation in athenad.py:
```python @dispatcher.add_method def remoteCommand(command: str, args:dict) -> str: from openpilot.system.remoted.remote import remoteCommand return remoteCommand(command, args) ```
This dispatcher method allows me to send any command from the web app to the car's system. From there I can execute any command I wanted to based on the service payload. The video shows a signal being sent and received with it being outputted onto the device as an Offroad Alert.
unexpected issues:
- ⊳ Finding the appropriate timing to send the signal took some trial and error. Initially a 2 second delay led to offroad alerts not being display as it didn't give the device enough time to read the parameters of the device.
script to control the car remotely
As a proof of concept, I wanted to play with the dashboard of my car to give it "raveMode". A portion of the hackathon was spent understanding the system of how car ECUs communicate with each other, as well as understanding how the device sends the appropriate messages based on the specific car plugged in. Below is the script I wrote that was just to play around with the Dashboard UI of my sonata.
```python
def flashLights(args: dict):
print("Flash Lights")
lightFlip = False
while is_command_active('flashLights'):
print("Running...")
# Debug: Check the current state of the command
print(f"Command active: {is_command_active('flashLights')}")
# Check if the thread should stop
if not getattr(threading.current_thread(), "do_run", True):
print("Flash Lights command deactivated.")
break # Exit the loop if deactivated
start_time = time.time()
while time.time() - start_time < 1:
CC.hudControl.leftLaneVisible = lightFlip
CC.hudControl.rightLaneVisible = lightFlip
CC.leftBlinker = lightFlip
CC.rightBlinker = lightFlip
CC.enabled = lightFlip
flash_send = messaging.new_message('carControl')
flash_send.valid = CS.canValid
flash_send.carControl = CC
pm.send('carControl', flash_send)
print(start_time)
lightFlip = not lightFlip
time.sleep(0.1) # Add a small delay to prevent rapid looping
# Ensure any necessary cleanup here
print("Flash Lights command completed or canceled.")
```
To understand how your car sends CAN packets across different ECUs, I recommend watching Robbe's talk on How Do We Control The Car? who is currently a Hardware Engineer at comma.
unexpected issues:
- ⊳ I found that although we have access to controlling the car such as steering, gas, and brakes, I found that we weren't necessarily exposed to the appropriate BUS that allowed me to send CAN messages that turned blinkers on/off.
- ⊳ This really depends on the car as certain messages may not work on all cars (The ev6 from KIA does not react the same to the messages as does my sonata.) This would involve some more investigation to provide a very generic solution for things such as HVAC.
- ⊳ As it stands we are unable to control things such as HVAC and blinkers. However after chatting with some engineers I realized that it is in fact possible, the approach just needed to be changed. In order to access certain ECUs one can communicate with them directly through UDS over the OBD-II port. While this solves the blocker that I had faced it still remains to be looked into since in order to have access one needs to go through the gateway of a car and it's often protected behind an encryption key.
Putting it all together
Finally it was time to put the remote signalling and the car control scripts working together. This proved to be much more difficult then I had anticipated.
The difficult comes from providing on/off functionality, on initial implementation I ran into `address in use errors` signalling that the controls were being in use. To fix this I implemented threading as cases such as lights are in a loop and must be dismissed on the second event receieved from device (e.g {"isActive": "False"}).
```python
# this should contain all the commands that can be run remotely
def runCommand(command: str, args: dict):
def command_thread():
from openpilot.system.remoted.commands import command_map
try:
print(f"Running command: {command} with args: {args}")
if command in command_map:
# Example of a loop that checks the do_run flag
command_map[command](args)
# Add a sleep or wait mechanism to prevent busy-waiting
else:
print(f"Command {command} not found in command_map.")
finally:
# Ensure the IsRunningCommand flag is reset after command execution
params.put_bool("IsRunningCommand", False)
params.remove("Offroad_IsRunningCommand")
# Remove the thread from the running_threads dictionary
running_threads.pop(command, None)
save_running_threads() # Save state after removing a command
params = Params()
# Check if the command is already running and should be canceled
if args['isActive'] == "False":
if command in running_threads:
print(f"Cancelling command: {command} as isActive is False")
# Check if the thread object is not None before accessing do_run
if running_threads[command] is not None:
running_threads[command].do_run = False
running_threads.pop(command, None)
save_running_threads() # Save state after cancelling a command
return "Command cancelled"
else:
return "No running command to cancel"
# Start a new thread for the command
thread = threading.Thread(target=command_thread)
thread.do_run = True # Custom attribute to control the thread
running_threads[command] = thread
save_running_threads() # Save state after adding a new command
print("Flash Lights execution started")
thread.start()
return "runCommand end"
```
After threading we see it working beautifully! Although the car controls are still WIP the POC of remote commands is there!
Final thoughts
Prior this hackathon, car controls was something I wasn't very confident in the openpilot codebase. Upon completing this project I've gained a lot of knowledge and understanding around the system and how it works.
With this new found knowledge I plan to start contributing to opendbc right away, the only repo that I've yet to contribute to. It seems like they just posted some bounties for it as well, the perfect opportunity to showcase what I learned (:
Major takeaways:
- ⊳ The remote commands works very quick and with low latency. Would need more testing to really push it to the limit.
- ⊳ UDS is the big thing I intend on looking into as it will allow me more control over my car.
- ⊳ The hackathon had so many dedicated and smart engineers that were willing and ready to help. It was truly a great experience!
Now it's back to work on both comma issues and my realtime api app! - mau