pipoint: add extra states and auto change based on remote input.

Makefile

@@ -22,7 +22,7 @@ LDFLAGS = -ldflags "-X $(PKG).Version=$(VERSION)"
 
 # Watch for changes, build, and push.
 watch:
-	watchman-make -p '**.go' -t push
+	watchman-make -p '**/*.go' -t push
 
 run:
 	go get $(LDFLAGS) $(PKG)/pipoint

cycle.go

@@ -25,6 +25,10 @@ type CycleState struct {
 	cycle float64
 }
 
+func (s *CycleState) Name() string {
+	return "Cycle"
+}
+
 // Update reacts to changes in parameters.
 func (s *CycleState) Update(param *Param) {
 	switch param {

hold.go

@@ -0,0 +1,33 @@
+// Copyright 2017 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package pipoint
+
+// HoldState executes when the camera is tracking the rover.
+type HoldState struct {
+	pi *PiPoint
+}
+
+func (s *HoldState) Name() string {
+	return "Hold"
+}
+
+// Update is called when a param is updated.
+func (s *HoldState) Update(param *Param) {
+	switch param {
+	case s.pi.mark:
+		s.pi.state.Dec()
+	}
+}

locate.go

@@ -17,7 +17,12 @@ package pipoint
 
 // LocateState runs initially to locate the base unit.
 type LocateState struct {
-	pi *PiPoint
+	name string
+	pi   *PiPoint
+}
+
+func (s *LocateState) Name() string {
+	return "Locate"
 }
 
 // Update is called when a param is updated.
@@ -31,5 +36,7 @@ func (s *LocateState) Update(param *Param) {
 		s.pi.offset.Set(&Attitude{
 			Yaw: s.pi.attitude.Get().(*Attitude).Yaw,
 		})
+	case s.pi.mark:
+		s.pi.state.Inc()
 	}
 }

orientate.go

@@ -0,0 +1,58 @@
+// Copyright 2017 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package pipoint
+
+// OrientateState runs to set the pan orientation.
+type OrientateState struct {
+	name string
+	pi *PiPoint
+}
+
+func (s *OrientateState) Name() string {
+	return "Orientate"
+}
+
+// Update is called when a param is updated.
+func (s *OrientateState) Update(param *Param) {
+	switch param {
+	case s.pi.neu:
+		s.pi.rover.Set(param.Get())
+	case s.pi.mark:
+		s.pi.state.Inc()
+	}
+
+	if param != s.pi.rover {
+		return
+	}
+	
+	if !s.pi.rover.Ok() || !s.pi.base.Ok() {
+		return
+	}
+
+	rover := s.pi.rover.Get().(*NEUPosition)
+	base := s.pi.base.Get().(*NEUPosition)
+	offset := s.pi.baseOffset.Get().(*NEUPosition)
+
+	att, err := point(rover, base, offset)
+
+	if err != nil {
+		return
+	}
+
+	s.pi.offset.Set(&Attitude{
+		Yaw: -att.Yaw,
+	})
+}

param.go

@@ -121,6 +121,11 @@ func (p *Param) Inc() error {
 	return p.SetInt(p.GetInt() + 1)
 }
 
+// Dec tries to decrement the integer value.
+func (p *Param) Dec() error {
+	return p.SetInt(p.GetInt() - 1)
+}
+
 // Finalise marks the param as always valid.
 func (p *Param) Finalise() {
 	p.final = true

pipoint.go

@@ -16,7 +16,6 @@
 package pipoint
 
 import (
-	"fmt"
 	"log"
 	"time"
 
@@ -36,6 +35,7 @@ var (
 
 // State is a handler for the current state of the system.
 type State interface {
+	Name() string
 	Update(param *Param)
 }
 
@@ -103,7 +103,9 @@ func NewPiPoint() *PiPoint {
 
 	p.states = []State{
 		&LocateState{pi: p},
+		&OrientateState{pi: p},
 		&RunState{pi: p},
+		&HoldState{pi: p},
 		&CycleState{pi: p},
 	}
 
@@ -198,18 +200,28 @@ func (pi *PiPoint) predict(gps *Position) {
 }
 
 func (pi *PiPoint) update(param *Param) {
-	state := pi.state.GetInt()
-
-	if state >= 0 && state < len(pi.states) {
-		pi.states[state].Update(param)
+	if state := pi.getState(); state != nil {
+		state.Update(param)
 	}
 
 	pi.announce(param)
 	pi.log.Printf("%s %T %#v\n", param.Name, param.Get(), param.Get())
 }
 
+func (pi *PiPoint) getState() State {
+	state := pi.state.GetInt()
+	if state >= 0 && state < len(pi.states) {
+		return pi.states[state]
+	}
+	return nil
+}
+
 func (pi *PiPoint) announce(param *Param) {
 	switch param {
+	case pi.state:
+		if state := pi.getState(); state != nil {
+			pi.audio.Say(state.Name())
+		}
 	case pi.link:
 		link := param.GetInt()
 		if link != pi.linkLast {
@@ -225,15 +237,6 @@ func (pi *PiPoint) announce(param *Param) {
 		if param.GetInt() >= 3 {
 			pi.audio.Say("GPS ready")
 		}
-	case pi.mark:
-		pi.audio.Say("Mark")
-	case pi.seconds:
-		if (param.GetInt()%5) == 0 && pi.vel.Ok() {
-			kph := pi.vel.GetFloat64() * 3.6
-			if kph >= 1 {
-				pi.audio.Say(fmt.Sprintf("%.0f kph", kph))
-			}
-		}
 	}
 }
 

run.go

@@ -26,34 +26,48 @@ type RunState struct {
 	pi *PiPoint
 }
 
+func (s *RunState) Name() string {
+	return "Run"
+}
+
 // Update is called when a param is updated.
 func (s *RunState) Update(param *Param) {
 	switch param {
 	case s.pi.neu:
 		s.pi.rover.Set(param.Get())
+	case s.pi.seconds:
+		if (param.GetInt()%5) == 0 && s.pi.vel.Ok() {
+			kph := s.pi.vel.GetFloat64() * 3.6
+			if kph >= 2 {
+				s.pi.audio.Say(fmt.Sprintf("%.0f kph", kph))
+			}
+		}
+	case s.pi.mark:
+		s.pi.state.Inc()
+	}
+
+	if param != s.pi.rover {
+		return
 	}
 
 	if !s.pi.rover.Ok() || !s.pi.base.Ok() {
-		// Location is invalid or old.
-		log.Println("run: skipping as invalid or old", s.pi.rover.Ok(), s.pi.base.Ok())
 		return
 	}
 
+	
 	rover := s.pi.rover.Get().(*NEUPosition)
 	base := s.pi.base.Get().(*NEUPosition)
-	offset := s.pi.baseOffset.Get().(*NEUPosition)
+	baseOffset := s.pi.baseOffset.Get().(*NEUPosition)
 
-	att, err := point(rover, base, offset)
+	att, err := point(rover, base, baseOffset)
 	if err != nil {
 		log.Printf("point: %v\n", err)
 		return
 	}
 
-	if param == s.pi.neu {
-		offset := s.pi.offset.Get().(*Attitude)
-		s.pi.pan.Set(WrapAngle(att.Yaw + offset.Yaw))
-		s.pi.tilt.Set(WrapAngle(att.Pitch + offset.Pitch))
-	}
+	offset := s.pi.offset.Get().(*Attitude)
+	s.pi.pan.Set(WrapAngle(att.Yaw + offset.Yaw))
+	s.pi.tilt.Set(WrapAngle(att.Pitch + offset.Pitch))
 }
 
 func point(rover, base, offset *NEUPosition) (*Attitude, error) {