func main() {
if _, err := parser.Parse(); err != nil {
log.Fatalf("failed to parse options: %v", err)
}
log.Info("%v", opts)
motor := motor.New(
conf.MotorStepPin,
conf.MotorStepPwm,
conf.MotorDirPin,
conf.MotorSleepPin)
sol := step{392, time.Duration(250 * time.Millisecond), time.Duration(0 * time.Millisecond)}
solLL := step{392, time.Duration(1000 * time.Millisecond), time.Duration(0 * time.Millisecond)}
la := step{440, time.Duration(250 * time.Millisecond), time.Duration(0 * time.Millisecond)}
laL := step{440, time.Duration(500 * time.Millisecond), time.Duration(0 * time.Millisecond)}
si := step{494, time.Duration(500 * time.Millisecond), time.Duration(0 * time.Millisecond)}
siL := step{494, time.Duration(250 * time.Millisecond), time.Duration(0 * time.Millisecond)}
// might be a little deceptive but this is not playing mario's theme!
steps := []step{
sol,
sol,
sol,
la,
si,
laL,
sol,
siL,
la,
la,
solLL,
// {587, time.Duration(125 * time.Millisecond), time.Duration(125 * time.Millisecond)},
// {587, time.Duration(125 * time.Millisecond), time.Duration(250 * time.Millisecond)},
// {587, time.Duration(125 * time.Millisecond), time.Duration(250 * time.Millisecond)},
// {494, time.Duration(200 * time.Millisecond), time.Duration(250 * time.Millisecond)},
// {587, time.Duration(200 * time.Millisecond), time.Duration(250 * time.Millisecond)},
// {699, time.Duration(200 * time.Millisecond), time.Duration(250 * time.Millisecond)},
// {587, time.Duration(125 * time.Millisecond), time.Duration(125 * time.Millisecond)},
}
for _, s := range steps {
doStep(motor, opts.Clockwise, s.stepsBySecond, s.duration)
time.Sleep(250 * time.Millisecond)
}
}
func main() {
motor := motor.New(
conf.MotorStepPin,
conf.MotorStepPwm,
conf.MotorDirPin,
conf.MotorSleepPin)
stepCount := 201
steps := make([]step, stepCount)
for i := 1; i < stepCount; i++ {
steps[i] = step{id: i, stepsBySecond: 200, rotationInDegree: float64(i) * 1.8}
}
fmt.Println(steps)
for _, s := range steps {
doStep(motor, s)
time.Sleep(510 * time.Millisecond)
}
}
func main() {
if _, err := parser.Parse(); err != nil {
log.Fatalf("failed to parse options: %v", err)
}
log.Info("%v", opts)
motor := motor.New(
conf.MotorStepPin,
conf.MotorStepPwm,
conf.MotorDirPin,
conf.MotorSleepPin)
steps := []struct {
clockwise bool
stepsBySecond uint32
duration time.Duration
}{
// {true, 100, time.Duration(0.4 * float64(time.Second))},
// {true, 200, time.Duration(0.8 * float64(time.Second))},
{opts.Clockwise, opts.Speed, time.Duration(opts.Duration * float64(time.Second))},
// {opts.Clockwise, opts.Speed / 2, time.Duration(opts.Duration * float64(time.Second) / 4)},
// {true, 400, 5 * time.Second},
// {false, 200, 5 * time.Second},
// {false, 400, 5 * time.Second},
}
motor.Enable()
for i := 0; i < opts.Repetition; i++ {
for _, s := range steps {
step(motor, s.clockwise, s.stepsBySecond, s.duration)
}
time.Sleep(time.Duration(opts.Pause * float64(time.Second)))
}
motor.Disable()
}
func main() {
// parse inputs
if _, err := parser.Parse(); err != nil {
log.Fatalf("failed to parse options: %v", err)
}
// Scenario input format
// we want scenario with different speed
// we want scenario with positive and negative steering changes
// we want different values of those changes
// we want different initial steering (do we?)
// we want a scenario where we just go straight to record the noise
// ---> all that can be defined with the step height and the duration
log.Info("Starting -- version %s", Version)
log.Info("Opts: %#v", opts)
panicChan := make(chan interface{})
defer func() {
if r := recover(); r != nil {
panicChan <- r
}
}()
stepperChan := make(chan interface{})
// The motor
motor := motor.New(
conf.MotorStepPin,
conf.MotorStepPwm,
conf.MotorDirPin,
conf.MotorSleepPin)
defer motor.Unexport()
// the input button
switchGpio := func(pin byte) gpio.Gpio {
// kill the process (via log.Panic) in case we can't create the GPIO
err := gpio.EnableGPIO(pin)
if err != nil {
log.Panic(err)
}
var g = gpio.New(pin)
if !g.IsExported() {
err = g.Export()
if err != nil {
log.Panic(err)
}
}
err = g.SetDirection(gpio.InDirection)
if err != nil {
log.Panic(err)
}
err = g.SetActiveLevel(gpio.ActiveHigh)
if err != nil {
log.Panic(err)
}
// Test we can read it and make we we don't go beyond this point until the switch is OFF
// to prevent the autopilot to be re-enabled when the system restart.
// Since the alarm has not been initialized yet, after a reboot it will be ON.
for value, err := g.Value(); value; value, err = g.Value() {
if err != nil {
log.Panic(err)
}
log.Info("[AUTOTEST] current autopilot switch position is ON - switch it OFF to proceed.")
time.Sleep(200 * time.Millisecond)
}
return g
}(conf.SwitchGpioPin)
defer switchGpio.Unexport()
////////////////////////////////////////
// an astonishing steering
////////////////////////////////////////
steering := steering.New(motor)
steeringChan := make(chan interface{})
steering.SetInputChan(steeringChan)
steering.SetPanicChan(panicChan)
////////////////////////////////////////
// a fake tracer
////////////////////////////////////////
tracerChan := make(chan interface{})
go func() {
for {
<-tracerChan
}
}()
////////////////////////////////////////
// a wonderful gps
////////////////////////////////////////
gps := gps.New(conf.Conf.GpsSerialPort)
gps.SetMessagesChan(stepperChan)
gps.SetErrorChan(stepperChan)
gps.SetPanicChan(panicChan)
gps.SetTracerChan(tracerChan)
////////////////////////////////////////
// a crazy stepper
////////////////////////////////////////
stepper := stepper.New()
stepper.SetInputChan(stepperChan)
stepper.SetPanicChan(panicChan)
stepper.SetSteeringChan(steeringChan)
////////////////////////////////////////
// a surprising input
////////////////////////////////////////
control := control.New(switchGpio, stepper)
control.SetPanicChan(panicChan)
// tell the pilot what we are going to do
log.Notice(`When the autopilot button is switched to ON, we are going to acquire the
current heading and start a steering step of %f degree and hold it for %v. As a pilot,
you'll have to make sure there is enough place for that and the vessel is safe.
Changing the steering during the test will make it invalide.
When the test is over your are free to resume normal operations.`, opts.Step, opts.Duration)
gps.Start()
control.Start()
steering.Start()
stepper.Start()
defer steering.Shutdown()
defer stepper.Shutdown()
defer control.Shutdown()
go func() {
select {
case m := <-panicChan:
// make sure the motor is stopped
err := motor.Disable()
if err != nil {
log.Error("Failed to disable the motor - exiting anyway", err)
}
log.Fatalf("Version %v -- Received a panic error -- exiting: %v", Version, m)
}
}()
go func() {
defer func() {
if r := recover(); r != nil {
panicChan <- r
}
}()
http.HandleFunc("/", webserver.VersionEndpoint(Version))
http.HandleFunc("/calibration", stepper.CalibrationEndpoint)
err := http.ListenAndServe(":8000", nil)
if err != nil {
log.Panic("Already running! or something is living on port 8000 - exiting")
}
}()
// populate the scenario
stepper.NewStep(opts.Step, time.Duration(opts.Duration)*time.Second, opts.Description)
// FUTURE(ssoudan) We can imagine to generate the input from matlab? :)
// FUTURE(ssoudan) support periodic response testing
// Wait until we receive a signal
utils.WaitForInterrupt(func() {
log.Info("Interrupted - exiting")
log.Info("Exiting -- version %v", Version)
})
}
func main() {
log.Info("Starting -- version %s", Version)
panicChan := make(chan interface{})
defer func() {
if r := recover(); r != nil {
panicChan <- r
}
}()
go func() {
select {
case m := <-panicChan:
// kill the process (via log.Fatal) in case we can't create the PWM
if pwm, err := pwm.New(conf.AlarmGpioPWM, conf.AlarmGpioPin); err == nil {
if !pwm.IsExported() {
err = pwm.Export()
if err != nil {
log.Error("Failed to raise the alarm")
}
}
pwm.Enable()
} else {
log.Error("Failed to raise the alarm")
}
// The motor
motor := motor.New(
conf.MotorStepPin,
conf.MotorStepPwm,
conf.MotorDirPin,
conf.MotorSleepPin)
if err := motor.Disable(); err != nil {
log.Error("Failed to stop the motor")
}
motor.Unexport()
log.Fatalf("Version %v -- Received a panic error -- exiting: %v", Version, m)
}
}()
ws := webserver.New(Version)
ws.SetPanicChan(panicChan)
ws.Start()
////////////////////////////////////////
// Init the IO
////////////////////////////////////////
// the LEDs
mapMessageToGPIO := func(message string, pin byte) gpio.Gpio {
// kill the process (via log.Panic -> recover -> panicChan -> go routine -> log.Fatal) in case we can't create the GPIO
err := gpio.EnableGPIO(pin)
if err != nil {
log.Panic(err)
}
var g = gpio.New(pin)
if !g.IsExported() {
err = g.Export()
if err != nil {
log.Panic(err)
}
}
err = g.SetDirection(gpio.OutDirection)
if err != nil {
log.Panic(err)
}
// Test Disabled and Enabled state for each LEDs
err = g.Disable()
if err != nil {
log.Panic(err)
}
log.Info("[AUTOTEST] %s LED is ON", message)
time.Sleep(1 * time.Second)
err = g.Enable()
if err != nil {
log.Panic(err)
}
log.Info("[AUTOTEST] %s LED is OFF", message)
time.Sleep(1 * time.Second)
err = g.Disable()
if err != nil {
log.Panic(err)
}
return g
}
dashboardGPIOs := make(map[string]gpio.Gpio, len(conf.MessageToPin))
for _, v := range conf.MessageToPin {
g := mapMessageToGPIO(v.Message, v.Pin)
dashboardGPIOs[v.Message] = g
}
defer func() {
for _, g := range dashboardGPIOs {
g.Disable()
g.Unexport()
}
}()
// the input button
switchGpio := func(pin byte) gpio.Gpio {
// kill the process (via log.Panic) in case we can't create the GPIO
err := gpio.EnableGPIO(pin)
if err != nil {
log.Panic(err)
}
var g = gpio.New(pin)
if !g.IsExported() {
err = g.Export()
if err != nil {
log.Panic(err)
}
}
err = g.SetDirection(gpio.InDirection)
if err != nil {
log.Panic(err)
}
err = g.SetActiveLevel(gpio.ActiveHigh)
if err != nil {
log.Panic(err)
}
// Test we can read it and make we we don't go beyond this point until the switch is OFF
// to prevent the autopilot to be re-enabled when the system restart.
// Since the alarm has not been initialized yet, after a reboot it will be ON.
for value, err := g.Value(); value; value, err = g.Value() {
if err != nil {
log.Panic(err)
}
log.Info("[AUTOTEST] current autopilot switch position is ON - switch it OFF to proceed.")
time.Sleep(200 * time.Millisecond)
}
return g
}(conf.SwitchGpioPin)
defer switchGpio.Unexport()
// The motor
motor := motor.New(
conf.MotorStepPin,
conf.MotorStepPwm,
conf.MotorDirPin,
conf.MotorSleepPin)
defer motor.Disable()
defer motor.Unexport()
// The alarm
alarmPwm := func(pin byte, pwmId byte) *pwm.Pwm {
// kill the process (via log.Panic) in case we can't create the PWM
pwm, err := pwm.New(pwmId, pin)
if err != nil {
log.Panic(err)
}
if !pwm.IsExported() {
err = pwm.Export()
if err != nil {
log.Panic(err)
}
}
pwm.Disable()
if err = pwm.SetPeriodAndDutyCycle(200*time.Millisecond, 0.5); err != nil {
log.Panic(err)
}
if err = pwm.Enable(); err != nil {
log.Panic(err)
}
log.Info("[AUTOTEST] alarm is ON")
time.Sleep(2 * time.Second)
if err = pwm.Disable(); err != nil {
log.Panic(err)
}
log.Info("[AUTOTEST] alarm is OFF")
return pwm
}(conf.AlarmGpioPin, conf.AlarmGpioPWM)
defer alarmPwm.Unexport()
// The compass sincos output interface
compass := sincos.New(conf.I2CBus, conf.SinAddress, conf.CosAddress)
////////////////////////////////////////
// a nice and delicate alarm
////////////////////////////////////////
alarm := alarm.New(alarmPwm)
alarmChan := make(chan interface{})
alarm.SetInputChan(alarmChan)
alarm.SetPanicChan(panicChan)
////////////////////////////////////////
// a beautiful dashboard
////////////////////////////////////////
dashboard := dashboard.New()
dashboardChan := make(chan interface{})
dashboard.SetInputChan(dashboardChan)
dashboard.SetPanicChan(panicChan)
for m, g := range dashboardGPIOs {
dashboard.RegisterMessageHandler(m, g)
}
ws.SetDashboard(dashboard)
////////////////////////////////////////
// an astonishing steering
////////////////////////////////////////
steering := steering.New(motor)
steeringChan := make(chan interface{})
steering.SetInputChan(steeringChan)
steering.SetPanicChan(panicChan)
////////////////////////////////////////
// a stunning tracer
////////////////////////////////////////
tracer := tracer.New(conf.Conf.TraceSize)
tracerChan := make(chan interface{})
tracer.SetInputChan(tracerChan)
tracer.SetPanicChan(panicChan)
ws.SetTracer(tracer)
////////////////////////////////////////
// an amazing PID
////////////////////////////////////////
pidController := pid.New(
conf.Conf.P,
conf.Conf.I,
conf.Conf.D,
conf.Conf.N,
conf.Conf.MinPIDOutputLimits,
conf.Conf.MaxPIDOutputLimits)
////////////////////////////////////////
// a great pilot
////////////////////////////////////////
thePilot := pilot.New(pidController, conf.Conf.Bounds)
pilotChan := make(chan interface{})
thePilot.SetInputChan(pilotChan)
thePilot.SetDashboardChan(dashboardChan)
thePilot.SetAlarmChan(alarmChan)
thePilot.SetSteeringChan(steeringChan)
thePilot.SetPanicChan(panicChan)
ws.SetPilot(thePilot)
////////////////////////////////////////
// a surprising input
////////////////////////////////////////
control := control.New(switchGpio, thePilot)
control.SetPanicChan(panicChan)
////////////////////////////////////////
// a friendly interface to the AP100
////////////////////////////////////////
ap100 := ap100.New(compass)
headingChan := make(chan interface{})
ap100.SetInputChan(headingChan)
ap100.SetPanicChan(panicChan)
////////////////////////////////////////
// a wonderful gps
////////////////////////////////////////
gps := gps.New(conf.Conf.GpsSerialPort)
gps.SetMessagesChan(pilotChan)
gps.SetHeadingChan(headingChan)
gps.SetErrorChan(pilotChan)
gps.SetPanicChan(panicChan)
gps.SetTracerChan(tracerChan)
tracer.Start()
defer tracer.Shutdown()
ap100.Start()
defer ap100.Shutdown()
gps.Start()
control.Start()
defer control.Shutdown()
alarm.Start()
defer alarm.Shutdown()
dashboard.Start()
defer dashboard.Shutdown()
steering.Start()
defer steering.Shutdown()
thePilot.Start()
defer thePilot.Shutdown()
// Wait until we receive a signal
utils.WaitForInterrupt(func() {
log.Info("Interrupted - exiting")
log.Info("Exiting -- version %v", Version)
})
}