add registration

Author: buxtronix

README.md

@@ -15,6 +15,7 @@ Tested against a MY18 vehicle.
 
  * MQTT proxy to Phev
  * Home Assistant discovery
+ * Register client to car
  * Fetch battery, charge, door, light status
  * Set lights and charge enable
  * Near-instant response to commands
@@ -25,8 +26,6 @@ Also includes some debugging utilities.
 ## Requirements
 
  * Go compiler
- * To connect, a previously registered connection to a phone/tablet.
-   * This library doesnt yet support client registration.
 
 ## Licence, etc
 
@@ -59,24 +58,25 @@ Contributions and PRs are welcome.
 
 ### Connecting to the vehicle.
 
-#### Register a mobile device with official app
+#### Configure Wifi client on system running mqtt2phev
 
-As the program does not (yet) support client registration, you will first need to
-register a phone/tablet to the car. Follow the [Mitsubishi instructions](https://www.mitsubishi-motors.com/en/products/outlander_phev/app/remote/)
-and register the phone app to the car. You will need the Wifi credentials provided
-with the car.
+On your computer running the phev2mqtt tools, configure a new Wifi connection to the
+car's SSID,
 
-#### Obtain MAC address the app uses
+#### Register the client to the car
 
-Next, find the MAC address of the client. On your phone/table, go to Wifi settings,
-search for the car SSID and find the MAC address used. On Android this will likely
-be a randomised address. Note this address down.
+Follow the [Mitsubishi instructions](https://www.mitsubishi-motors.com/en/products/outlander_phev/app/remote/)
+to find the Wifi credentials provided with the car.
 
-#### Configure Wifi client on system running mqtt2phev
+Verify that your Wifi connection to the car is established - your local IP address
+should be 192.168.8.47.
 
-On your computer running the phev2mqtt tools, configure a new Wifi connection to the
-car's SSID, and it's also essential to set the Wifi adapter mac address to the client
-MAC address you noted above. Poke around online for how to do this for your system.
+Follow the [Mitsubishi instructions](https://www.mitsubishi-motors.com/en/products/outlander_phev/app/remote/)
+and put the car into registration mode ("Setup Your Vehicle"). You may need to
+re-establish the Wifi connection.
+
+Register by running `phev2mqtt client register` and you should shortly see a message
+indicating successful registration.
 
 #### Testing the tool
 

client/client.go

@@ -61,6 +61,7 @@ type Client struct {
 
 	address string
 	conn    net.Conn
+	lastRx  time.Time
 	started chan struct{}
 
 	key *protocol.SecurityKey
@@ -137,6 +138,7 @@ func (c *Client) Connect() error {
 	go c.reader()
 	go c.writer()
 	go c.manage()
+	go c.pinger()
 
 	return nil
 }
@@ -215,6 +217,31 @@ func (c *Client) nextRecvMsg(deadline time.Time) (*protocol.PhevMessage, error)
 	}
 }
 
+// Sends periodic pings to the car.
+func (c *Client) pinger() {
+	pingSeq := byte(0xa)
+	ticker := time.NewTicker(200 * time.Millisecond)
+	defer ticker.Stop()
+	for t := range ticker.C {
+		switch {
+		case c.closed:
+			return
+		case t.Sub(c.lastRx) < 500*time.Millisecond:
+			continue
+		}
+		c.Send <- &protocol.PhevMessage{
+			Type:     protocol.CmdOutPingReq,
+			Ack:      protocol.Request,
+			Register: pingSeq,
+			Data:     []byte{0x0},
+		}
+		pingSeq++
+		if pingSeq > 0x63 {
+			pingSeq = 0
+		}
+	}
+}
+
 // manages the connection, handling control messages.
 func (c *Client) manage() {
 	ml := c.AddListener()
@@ -274,6 +301,7 @@ func (c *Client) reader() {
 			c.lMu.Unlock()
 			return
 		}
+		c.lastRx = time.Now()
 		log.Tracef("%%PHEV_TCP_RECV_DATA%%: %s", hex.EncodeToString(data[:n]))
 		messages := protocol.NewFromBytes(data[:n], c.key)
 		for _, m := range messages {
@@ -297,9 +325,9 @@ func (c *Client) writer() {
 				c.conn.Close()
 				return
 			}
-			log.Debugf("%%PHEV_TCP_SEND_MSG%%: [%02x] %s", msg.Xor, msg.ShortForm())
 			msg.Xor = 0
 			data := msg.EncodeToBytes(c.key)
+			log.Debugf("%%PHEV_TCP_SEND_MSG%%: [%02x] %s", msg.Xor, msg.ShortForm())
 			log.Tracef("%%PHEV_TCP_SEND_DATA%%: %s", hex.EncodeToString(data))
 			c.conn.(*net.TCPConn).SetWriteDeadline(time.Now().Add(15 * time.Second))
 			if _, err := c.conn.Write(data); err != nil {

cmd/pcap.go

@@ -46,6 +46,7 @@ The decoder filters TCP packets to and from port 8080.
 		}
 		defer handle.Close()
 		securityKey = &protocol.SecurityKey{}
+		pings, _ = cmd.Flags().GetBool("pings")
 
 		packetSource := gopacket.NewPacketSource(handle, handle.LinkType())
 		var currentTime time.Time
@@ -114,6 +115,9 @@ func processPayload(cmd *cobra.Command, data []byte, dir string) {
 			handleRegisters(msg)
 			return
 		}
+		if !pings && (msg.Type == protocol.CmdOutPingReq || msg.Type == protocol.CmdInPingResp) {
+			return
+		}
 		log.Infof("%s [%02x] %s", dir, msg.Xor, msg.ShortForm())
 	}
 }
@@ -122,11 +126,17 @@ var securityKey *protocol.SecurityKey
 
 var regs = map[byte]string{}
 
+var pings bool
+
 func handleRegisters(m *protocol.PhevMessage) {
 	if m.Type == protocol.CmdInResp {
 		data := hex.EncodeToString(m.Data)
 		if d := regs[m.Register]; d != data {
-			log.Infof("UPDATEREG 0x%02x: %s -> %s\n", m.Register, d, data)
+			if m.Reg != nil {
+				log.Infof("UPDATEREG 0x%02x: %s -> %s (%s)\n", m.Register, d, data, m.Reg.String())
+			} else {
+				log.Infof("UPDATEREG 0x%02x: %s -> %s\n", m.Register, d, data)
+			}
 			regs[m.Register] = data
 		}
 	}
@@ -147,4 +157,5 @@ func init() {
 	pcapCmd.Flags().StringP("direction", "d", "both", "Direction to decode")
 	pcapCmd.Flags().BoolP("latency", "l", false, "Replay with original network latency")
 	pcapCmd.Flags().BoolP("registers", "R", false, "Show register updates")
+	pcapCmd.Flags().BoolP("pings", "P", false, "Show ping requests and responses")
 }

cmd/register.go

@@ -30,12 +30,29 @@ import (
 var registerCmd = &cobra.Command{
 	Use:   "register",
 	Short: "Register client with the car",
-	//	Args:  cobra.MinimumNArgs(1),
 	Long: `Register phev2mqtt with the car.
 
 You will need to first put the car into registration mode, then run
 this command within 5 minutes.
 
+The car will register the MAC address that connects to it - typically the
+MAC address of the TCP client that ultimately connects to the car. If you
+are going via a NAT gateway, etc, then bear this in mind.
+
+`,
+	Run: runRegister,
+}
+
+// unRegisterCmd represents the unregister command
+var unRegisterCmd = &cobra.Command{
+	Use:   "unregister",
+	Short: "Un register client from the car",
+	Long: `Unregister this phev2mqtt instance from the car.
+
+The car will unregister the MAC address that connects to it - typically the
+MAC address of the TCP client that ultimately connects to the car. If you
+are going via a NAT gateway, etc, then bear this in mind.
+
 `,
 	Run: runRegister,
 }
@@ -94,21 +111,26 @@ func runRegister(cmd *cobra.Command, args []string) {
 		log.Errorf("Client closed before recieving VIN")
 		return
 	}
-	fmt.Printf("Car VIN is %s - attempting to register...\n", vin)
 
 	reg := byte(0x10)
-	if unreg, _ := cmd.Flags().GetBool("unregister"); unreg {
+	if cmd.Use == "unregister" {
+		fmt.Printf("Attempting to unregister from car (VIN: %s)...\n", vin)
 		reg = 0x15
+	} else {
+		fmt.Printf("Attempting to register to car (VIN: %s)...\n", vin)
 	}
 	if err := cl.SetRegister(reg, []byte{0x1}); err != nil {
-		log.Errorf("Failed to register: %v", err)
+		log.Errorf("Failed to (un)register: %v", err)
 		return
 	}
-	fmt.Printf("Successfully registered!\n")
+	cl.Close()
+	time.Sleep(time.Second)
+	fmt.Printf("Success!\n")
 }
 
 func init() {
 	clientCmd.AddCommand(registerCmd)
+	clientCmd.AddCommand(unRegisterCmd)
 
 	// Here you will define your flags and configuration settings.
 
@@ -120,5 +142,5 @@ func init() {
 	// is called directly, e.g.:
 	// registerCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
 	registerCmd.Flags().Duration("wait_duration", 10*time.Second, "How long to wait after connecting to car before sending registration command")
-	registerCmd.Flags().Bool("unregister", false, "Remove existing registration (this mac address)")
+	unRegisterCmd.Flags().Duration("wait_duration", 10*time.Second, "How long to wait after connecting to car before sending registration command")
 }

cmd/root.go

@@ -28,6 +28,7 @@ import (
 var (
 	cfgFile  string
 	logLevel string
+	logTimes bool
 )
 
 // rootCmd represents the base command when called without any subcommands
@@ -42,6 +43,11 @@ var rootCmd = &cobra.Command{
 			panic(err)
 		}
 		log.SetLevel(level)
+		if logTimes {
+			log.SetFormatter(&log.TextFormatter{
+				FullTimestamp: true,
+			})
+		}
 	},
 
 	// Uncomment the following line if your bare application
@@ -64,6 +70,7 @@ func init() {
 
 	rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.phev2mqtt.yaml)")
 	rootCmd.PersistentFlags().StringVarP(&logLevel, "verbosity", "v", "info", "logging level to use")
+	rootCmd.PersistentFlags().BoolVarP(&logTimes, "log_timestamps", "t", false, "logging with timestamps")
 
 	// Cobra also supports local flags, which will only run
 	// when this action is called directly.

cmd/set.go

@@ -18,7 +18,9 @@ package cmd
 
 import (
 	"encoding/hex"
+	"fmt"
 	"strings"
+	"time"
 
 	"github.com/buxtronix/phev2mqtt/client"
 	//	log "github.com/sirupsen/logrus"
@@ -70,6 +72,15 @@ func runSet(cmd *cobra.Command, args []string) {
 		}
 	}
 
+	waitTime, err := cmd.Flags().GetDuration("wait_duration")
+	if err != nil {
+		panic(err)
+	}
+	sendInterval, err := cmd.Flags().GetDuration("send_interval")
+	if err != nil {
+		panic(err)
+	}
+
 	address, _ := cmd.Flags().GetString("address")
 	cl, err := client.New(client.AddressOption(address))
 	if err != nil {
@@ -83,11 +94,16 @@ func runSet(cmd *cobra.Command, args []string) {
 	if err := cl.Start(); err != nil {
 		panic(err)
 	}
+	fmt.Printf("Client connected and started!\nWaiting %d\n", waitTime.String())
+
+	time.Sleep(waitTime)
 
 	for _, reg := range setRegisters {
+		fmt.Printf("Setting register 0x%x to 0x%s\n", reg.register, hex.EncodeToString(reg.value))
 		if err := cl.SetRegister(reg.register, reg.value); err != nil {
 			panic(err)
 		}
+		time.Sleep(sendInterval)
 	}
 
 }
@@ -104,4 +120,6 @@ func init() {
 	// Cobra supports local flags which will only run when this command
 	// is called directly, e.g.:
 	// registerCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+	setCmd.Flags().Duration("wait_duration", 10*time.Second, "How long to wait after connecting to car before sending register update")
+	setCmd.Flags().Duration("send_interval", 1*time.Second, "Interval between setting each register")
 }

go.mod

@@ -5,9 +5,11 @@ go 1.16
 require (
 	github.com/d4l3k/messagediff v1.2.1 // indirect
 	github.com/eclipse/paho.mqtt.golang v1.3.5
+	github.com/google/btree v1.0.0 // indirect
 	github.com/google/gopacket v1.1.19
 	github.com/sirupsen/logrus v1.8.1
 	github.com/spf13/cobra v1.2.1
 	github.com/spf13/viper v1.8.1
+	golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6 // indirect
 	gopkg.in/d4l3k/messagediff.v1 v1.2.1
 )

protocol/message.go

@@ -3,6 +3,7 @@ package protocol
 import (
 	"encoding/hex"
 	"fmt"
+	log "github.com/sirupsen/logrus"
 )
 
 const (
@@ -134,6 +135,7 @@ func (p *PhevMessage) EncodeToBytes(key *SecurityKey) []byte {
 		// Use but do not increment send key.
 		xor = key.SKey(false)
 	}
+	p.Xor = xor
 	return XorMessageWith(data, xor)
 }
 
@@ -200,6 +202,7 @@ func (p *PhevMessage) String() string {
 func NewFromBytes(data []byte, key *SecurityKey) []*PhevMessage {
 	msgs := []*PhevMessage{}
 
+	log.Tracef("%%PHEV_DECODE_FROM_BYTES%%: Raw: %s", hex.EncodeToString(data))
 	offset := 0
 	for {
 		dat, xor, rem := ValidateAndDecodeMessage(data[offset:])
@@ -210,6 +213,7 @@ func NewFromBytes(data []byte, key *SecurityKey) []*PhevMessage {
 			}
 			continue
 		}
+		log.Tracef("%%PHEV_DECODED_FROM_BYTES%%: Raw: %s", hex.EncodeToString(dat))
 		dat = XorMessageWith(dat, xor)
 		p := &PhevMessage{}
 		err := p.DecodeFromBytes(dat, key)
@@ -224,6 +228,7 @@ func NewFromBytes(data []byte, key *SecurityKey) []*PhevMessage {
 			break
 		}
 		data = rem
+		offset = 0
 	}
 	return msgs
 }